﻿
#region Using directives

using System;
using System.Collections;
using System.Collections.Specialized;


using System.Web.Configuration;
using System.Data;
using System.Data.Common;
using System.Configuration.Provider;

using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Sql;

using NetROS.Tiers.Entities;
using NetROS.Tiers.Data;
using NetROS.Tiers.Data.Bases;

#endregion

namespace NetROS.Tiers.Data.SqlClient
{
	/// <summary>
	/// This class is the Sql implementation of the NetTiersProvider.
	/// </summary>
	public sealed class SqlNetTiersProvider : NetROS.Tiers.Data.Bases.NetTiersProvider
	{
		private static object syncRoot = new Object();
		private string _applicationName;
        private string _connectionString;
        private bool _useStoredProcedure;
        string _providerInvariantName;
		
		/// <summary>
		/// Initializes a new instance of the <see cref="SqlNetTiersProvider"/> class.
		///</summary>
		public SqlNetTiersProvider()
		{	
		}		
		
		/// <summary>
        /// Initializes the provider.
        /// </summary>
        /// <param name="name">The friendly name of the provider.</param>
        /// <param name="config">A collection of the name/value pairs representing the provider-specific attributes specified in the configuration for this provider.</param>
        /// <exception cref="T:System.ArgumentNullException">The name of the provider is null.</exception>
        /// <exception cref="T:System.InvalidOperationException">An attempt is made to call <see cref="M:System.Configuration.Provider.ProviderBase.Initialize(System.String,System.Collections.Specialized.NameValueCollection)"></see> on a provider after the provider has already been initialized.</exception>
        /// <exception cref="T:System.ArgumentException">The name of the provider has a length of zero.</exception>
		public override void Initialize(string name, NameValueCollection config)
        {
            // Verify that config isn't null
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            // Assign the provider a default name if it doesn't have one
            if (String.IsNullOrEmpty(name))
            {
                name = "SqlNetTiersProvider";
            }

            // Add a default "description" attribute to config if the
            // attribute doesn't exist or is empty
            if (string.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "NetTiers Sql provider");
            }

            // Call the base class's Initialize method
            base.Initialize(name, config);

            // Initialize _applicationName
            _applicationName = config["applicationName"];

            if (string.IsNullOrEmpty(_applicationName))
            {
                _applicationName = "/";
            }
            config.Remove("applicationName");


            #region "Initialize UseStoredProcedure"
            string storedProcedure  = config["useStoredProcedure"];
           	if (string.IsNullOrEmpty(storedProcedure))
            {
                throw new ProviderException("Empty or missing useStoredProcedure");
            }
            this._useStoredProcedure = Convert.ToBoolean(config["useStoredProcedure"]);
            config.Remove("useStoredProcedure");
            #endregion

			#region ConnectionString

			// Initialize _connectionString
			_connectionString = config["connectionString"];
			config.Remove("connectionString");

			string connect = config["connectionStringName"];
			config.Remove("connectionStringName");

			if ( String.IsNullOrEmpty(_connectionString) )
			{
				if ( String.IsNullOrEmpty(connect) )
				{
					throw new ProviderException("Empty or missing connectionStringName");
				}

				if ( DataRepository.ConnectionStrings[connect] == null )
				{
					throw new ProviderException("Missing connection string");
				}

				_connectionString = DataRepository.ConnectionStrings[connect].ConnectionString;
			}

            if ( String.IsNullOrEmpty(_connectionString) )
            {
                throw new ProviderException("Empty connection string");
			}

			#endregion
            
             #region "_providerInvariantName"

            // initialize _providerInvariantName
            this._providerInvariantName = config["providerInvariantName"];

            if (String.IsNullOrEmpty(_providerInvariantName))
            {
                throw new ProviderException("Empty or missing providerInvariantName");
            }
            config.Remove("providerInvariantName");

            #endregion

        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public override TransactionManager CreateTransaction()
		{
			return new TransactionManager(this._connectionString);
		}
		
		/// <summary>
		/// Gets a value indicating whether to use stored procedure or not.
		/// </summary>
		/// <value>
		/// 	<c>true</c> if this repository use stored procedures; otherwise, <c>false</c>.
		/// </value>
		public bool UseStoredProcedure
		{
			get {return this._useStoredProcedure;}
			set {this._useStoredProcedure = value;}
		}
		
		 /// <summary>
        /// Gets or sets the connection string.
        /// </summary>
        /// <value>The connection string.</value>
		public string ConnectionString
		{
			get {return this._connectionString;}
			set {this._connectionString = value;}
		}
		
		/// <summary>
	    /// Gets or sets the invariant provider name listed in the DbProviderFactories machine.config section.
	    /// </summary>
	    /// <value>The name of the provider invariant.</value>
	    public string ProviderInvariantName
	    {
	        get { return this._providerInvariantName; }
	        set { this._providerInvariantName = value; }
	    }		
		
		///<summary>
		/// Indicates if the current <c cref="NetTiersProvider"/> implementation supports Transacton.
		///</summary>
		public override bool IsTransactionSupported
		{
			get
			{
				return true;
			}
		}

		
		#region "OsobaProvider"
			
		private SqlOsobaProvider innerSqlOsobaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Osoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaProviderBase OsobaProvider
		{
			get
			{
				if (innerSqlOsobaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaProvider == null)
						{
							this.innerSqlOsobaProvider = new SqlOsobaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaProvider SqlOsobaProvider
		{
			get {return OsobaProvider as SqlOsobaProvider;}
		}
		
		#endregion
		
		
		#region "OsobaBankovniRacunProvider"
			
		private SqlOsobaBankovniRacunProvider innerSqlOsobaBankovniRacunProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaBankovniRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaBankovniRacunProviderBase OsobaBankovniRacunProvider
		{
			get
			{
				if (innerSqlOsobaBankovniRacunProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaBankovniRacunProvider == null)
						{
							this.innerSqlOsobaBankovniRacunProvider = new SqlOsobaBankovniRacunProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaBankovniRacunProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaBankovniRacunProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaBankovniRacunProvider SqlOsobaBankovniRacunProvider
		{
			get {return OsobaBankovniRacunProvider as SqlOsobaBankovniRacunProvider;}
		}
		
		#endregion
		
		
		#region "OsobaPlacaProvider"
			
		private SqlOsobaPlacaProvider innerSqlOsobaPlacaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaPlaca"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaPlacaProviderBase OsobaPlacaProvider
		{
			get
			{
				if (innerSqlOsobaPlacaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaPlacaProvider == null)
						{
							this.innerSqlOsobaPlacaProvider = new SqlOsobaPlacaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaPlacaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaPlacaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaPlacaProvider SqlOsobaPlacaProvider
		{
			get {return OsobaPlacaProvider as SqlOsobaPlacaProvider;}
		}
		
		#endregion
		
		
		#region "OsobaOrganizacijskaJedinicaProvider"
			
		private SqlOsobaOrganizacijskaJedinicaProvider innerSqlOsobaOrganizacijskaJedinicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaOrganizacijskaJedinica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaOrganizacijskaJedinicaProviderBase OsobaOrganizacijskaJedinicaProvider
		{
			get
			{
				if (innerSqlOsobaOrganizacijskaJedinicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaOrganizacijskaJedinicaProvider == null)
						{
							this.innerSqlOsobaOrganizacijskaJedinicaProvider = new SqlOsobaOrganizacijskaJedinicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaOrganizacijskaJedinicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaOrganizacijskaJedinicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaOrganizacijskaJedinicaProvider SqlOsobaOrganizacijskaJedinicaProvider
		{
			get {return OsobaOrganizacijskaJedinicaProvider as SqlOsobaOrganizacijskaJedinicaProvider;}
		}
		
		#endregion
		
		
		#region "OsobaObustavaNaknadaProvider"
			
		private SqlOsobaObustavaNaknadaProvider innerSqlOsobaObustavaNaknadaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaObustavaNaknada"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaObustavaNaknadaProviderBase OsobaObustavaNaknadaProvider
		{
			get
			{
				if (innerSqlOsobaObustavaNaknadaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaObustavaNaknadaProvider == null)
						{
							this.innerSqlOsobaObustavaNaknadaProvider = new SqlOsobaObustavaNaknadaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaObustavaNaknadaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaObustavaNaknadaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaObustavaNaknadaProvider SqlOsobaObustavaNaknadaProvider
		{
			get {return OsobaObustavaNaknadaProvider as SqlOsobaObustavaNaknadaProvider;}
		}
		
		#endregion
		
		
		#region "OsobaPoreznaOlaksicaProvider"
			
		private SqlOsobaPoreznaOlaksicaProvider innerSqlOsobaPoreznaOlaksicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaPoreznaOlaksica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaPoreznaOlaksicaProviderBase OsobaPoreznaOlaksicaProvider
		{
			get
			{
				if (innerSqlOsobaPoreznaOlaksicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaPoreznaOlaksicaProvider == null)
						{
							this.innerSqlOsobaPoreznaOlaksicaProvider = new SqlOsobaPoreznaOlaksicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaPoreznaOlaksicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaPoreznaOlaksicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaPoreznaOlaksicaProvider SqlOsobaPoreznaOlaksicaProvider
		{
			get {return OsobaPoreznaOlaksicaProvider as SqlOsobaPoreznaOlaksicaProvider;}
		}
		
		#endregion
		
		
		#region "OsobaAdreseProvider"
			
		private SqlOsobaAdreseProvider innerSqlOsobaAdreseProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaAdrese"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaAdreseProviderBase OsobaAdreseProvider
		{
			get
			{
				if (innerSqlOsobaAdreseProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaAdreseProvider == null)
						{
							this.innerSqlOsobaAdreseProvider = new SqlOsobaAdreseProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaAdreseProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaAdreseProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaAdreseProvider SqlOsobaAdreseProvider
		{
			get {return OsobaAdreseProvider as SqlOsobaAdreseProvider;}
		}
		
		#endregion
		
		
		#region "_PostavkeRobnogProvider"
			
		private Sql_PostavkeRobnogProvider innerSql_PostavkeRobnogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="_PostavkeRobnog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override _PostavkeRobnogProviderBase _PostavkeRobnogProvider
		{
			get
			{
				if (innerSql_PostavkeRobnogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSql_PostavkeRobnogProvider == null)
						{
							this.innerSql_PostavkeRobnogProvider = new Sql_PostavkeRobnogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSql_PostavkeRobnogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="Sql_PostavkeRobnogProvider"/>.
		/// </summary>
		/// <value></value>
		public Sql_PostavkeRobnogProvider Sql_PostavkeRobnogProvider
		{
			get {return _PostavkeRobnogProvider as Sql_PostavkeRobnogProvider;}
		}
		
		#endregion
		
		
		#region "OsobaRadniOdnosProvider"
			
		private SqlOsobaRadniOdnosProvider innerSqlOsobaRadniOdnosProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaRadniOdnos"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaRadniOdnosProviderBase OsobaRadniOdnosProvider
		{
			get
			{
				if (innerSqlOsobaRadniOdnosProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaRadniOdnosProvider == null)
						{
							this.innerSqlOsobaRadniOdnosProvider = new SqlOsobaRadniOdnosProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaRadniOdnosProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaRadniOdnosProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaRadniOdnosProvider SqlOsobaRadniOdnosProvider
		{
			get {return OsobaRadniOdnosProvider as SqlOsobaRadniOdnosProvider;}
		}
		
		#endregion
		
		
		#region "OsobaRadnoMjestoProvider"
			
		private SqlOsobaRadnoMjestoProvider innerSqlOsobaRadnoMjestoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsobaRadnoMjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsobaRadnoMjestoProviderBase OsobaRadnoMjestoProvider
		{
			get
			{
				if (innerSqlOsobaRadnoMjestoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsobaRadnoMjestoProvider == null)
						{
							this.innerSqlOsobaRadnoMjestoProvider = new SqlOsobaRadnoMjestoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsobaRadnoMjestoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsobaRadnoMjestoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsobaRadnoMjestoProvider SqlOsobaRadnoMjestoProvider
		{
			get {return OsobaRadnoMjestoProvider as SqlOsobaRadnoMjestoProvider;}
		}
		
		#endregion
		
		
		#region "PrilagodenDokumentTipProvider"
			
		private SqlPrilagodenDokumentTipProvider innerSqlPrilagodenDokumentTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PrilagodenDokumentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PrilagodenDokumentTipProviderBase PrilagodenDokumentTipProvider
		{
			get
			{
				if (innerSqlPrilagodenDokumentTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPrilagodenDokumentTipProvider == null)
						{
							this.innerSqlPrilagodenDokumentTipProvider = new SqlPrilagodenDokumentTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPrilagodenDokumentTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPrilagodenDokumentTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPrilagodenDokumentTipProvider SqlPrilagodenDokumentTipProvider
		{
			get {return PrilagodenDokumentTipProvider as SqlPrilagodenDokumentTipProvider;}
		}
		
		#endregion
		
		
		#region "PorezProvider"
			
		private SqlPorezProvider innerSqlPorezProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Porez"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PorezProviderBase PorezProvider
		{
			get
			{
				if (innerSqlPorezProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPorezProvider == null)
						{
							this.innerSqlPorezProvider = new SqlPorezProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPorezProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPorezProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPorezProvider SqlPorezProvider
		{
			get {return PorezProvider as SqlPorezProvider;}
		}
		
		#endregion
		
		
		#region "ParametriNaziviProvider"
			
		private SqlParametriNaziviProvider innerSqlParametriNaziviProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ParametriNazivi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ParametriNaziviProviderBase ParametriNaziviProvider
		{
			get
			{
				if (innerSqlParametriNaziviProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlParametriNaziviProvider == null)
						{
							this.innerSqlParametriNaziviProvider = new SqlParametriNaziviProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlParametriNaziviProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlParametriNaziviProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlParametriNaziviProvider SqlParametriNaziviProvider
		{
			get {return ParametriNaziviProvider as SqlParametriNaziviProvider;}
		}
		
		#endregion
		
		
		#region "ParametriProvider"
			
		private SqlParametriProvider innerSqlParametriProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Parametri"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ParametriProviderBase ParametriProvider
		{
			get
			{
				if (innerSqlParametriProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlParametriProvider == null)
						{
							this.innerSqlParametriProvider = new SqlParametriProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlParametriProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlParametriProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlParametriProvider SqlParametriProvider
		{
			get {return ParametriProvider as SqlParametriProvider;}
		}
		
		#endregion
		
		
		#region "OSTipRetkaProvider"
			
		private SqlOSTipRetkaProvider innerSqlOSTipRetkaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OSTipRetka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OSTipRetkaProviderBase OSTipRetkaProvider
		{
			get
			{
				if (innerSqlOSTipRetkaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOSTipRetkaProvider == null)
						{
							this.innerSqlOSTipRetkaProvider = new SqlOSTipRetkaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOSTipRetkaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOSTipRetkaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOSTipRetkaProvider SqlOSTipRetkaProvider
		{
			get {return OSTipRetkaProvider as SqlOSTipRetkaProvider;}
		}
		
		#endregion
		
		
		#region "PrimanjeTipProvider"
			
		private SqlPrimanjeTipProvider innerSqlPrimanjeTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PrimanjeTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PrimanjeTipProviderBase PrimanjeTipProvider
		{
			get
			{
				if (innerSqlPrimanjeTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPrimanjeTipProvider == null)
						{
							this.innerSqlPrimanjeTipProvider = new SqlPrimanjeTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPrimanjeTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPrimanjeTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPrimanjeTipProvider SqlPrimanjeTipProvider
		{
			get {return PrimanjeTipProvider as SqlPrimanjeTipProvider;}
		}
		
		#endregion
		
		
		#region "OsnovnoSredstvoProvider"
			
		private SqlOsnovnoSredstvoProvider innerSqlOsnovnoSredstvoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsnovnoSredstvo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsnovnoSredstvoProviderBase OsnovnoSredstvoProvider
		{
			get
			{
				if (innerSqlOsnovnoSredstvoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsnovnoSredstvoProvider == null)
						{
							this.innerSqlOsnovnoSredstvoProvider = new SqlOsnovnoSredstvoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsnovnoSredstvoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsnovnoSredstvoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsnovnoSredstvoProvider SqlOsnovnoSredstvoProvider
		{
			get {return OsnovnoSredstvoProvider as SqlOsnovnoSredstvoProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijaTipProvider"
			
		private SqlOrganizacijaTipProvider innerSqlOrganizacijaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrganizacijaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijaTipProviderBase OrganizacijaTipProvider
		{
			get
			{
				if (innerSqlOrganizacijaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijaTipProvider == null)
						{
							this.innerSqlOrganizacijaTipProvider = new SqlOrganizacijaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijaTipProvider SqlOrganizacijaTipProvider
		{
			get {return OrganizacijaTipProvider as SqlOrganizacijaTipProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijaProvider"
			
		private SqlOrganizacijaProvider innerSqlOrganizacijaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Organizacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijaProviderBase OrganizacijaProvider
		{
			get
			{
				if (innerSqlOrganizacijaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijaProvider == null)
						{
							this.innerSqlOrganizacijaProvider = new SqlOrganizacijaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijaProvider SqlOrganizacijaProvider
		{
			get {return OrganizacijaProvider as SqlOrganizacijaProvider;}
		}
		
		#endregion
		
		
		#region "VrstaFinDokumentaProvider"
			
		private SqlVrstaFinDokumentaProvider innerSqlVrstaFinDokumentaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VrstaFinDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VrstaFinDokumentaProviderBase VrstaFinDokumentaProvider
		{
			get
			{
				if (innerSqlVrstaFinDokumentaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVrstaFinDokumentaProvider == null)
						{
							this.innerSqlVrstaFinDokumentaProvider = new SqlVrstaFinDokumentaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVrstaFinDokumentaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVrstaFinDokumentaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVrstaFinDokumentaProvider SqlVrstaFinDokumentaProvider
		{
			get {return VrstaFinDokumentaProvider as SqlVrstaFinDokumentaProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijaZiroRacunProvider"
			
		private SqlOrganizacijaZiroRacunProvider innerSqlOrganizacijaZiroRacunProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrganizacijaZiroRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijaZiroRacunProviderBase OrganizacijaZiroRacunProvider
		{
			get
			{
				if (innerSqlOrganizacijaZiroRacunProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijaZiroRacunProvider == null)
						{
							this.innerSqlOrganizacijaZiroRacunProvider = new SqlOrganizacijaZiroRacunProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijaZiroRacunProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijaZiroRacunProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijaZiroRacunProvider SqlOrganizacijaZiroRacunProvider
		{
			get {return OrganizacijaZiroRacunProvider as SqlOrganizacijaZiroRacunProvider;}
		}
		
		#endregion
		
		
		#region "TipKontaProvider"
			
		private SqlTipKontaProvider innerSqlTipKontaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TipKonta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TipKontaProviderBase TipKontaProvider
		{
			get
			{
				if (innerSqlTipKontaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTipKontaProvider == null)
						{
							this.innerSqlTipKontaProvider = new SqlTipKontaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTipKontaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlTipKontaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTipKontaProvider SqlTipKontaProvider
		{
			get {return TipKontaProvider as SqlTipKontaProvider;}
		}
		
		#endregion
		
		
		#region "ObustavaNaknadaTipProvider"
			
		private SqlObustavaNaknadaTipProvider innerSqlObustavaNaknadaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObustavaNaknadaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObustavaNaknadaTipProviderBase ObustavaNaknadaTipProvider
		{
			get
			{
				if (innerSqlObustavaNaknadaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObustavaNaknadaTipProvider == null)
						{
							this.innerSqlObustavaNaknadaTipProvider = new SqlObustavaNaknadaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObustavaNaknadaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObustavaNaknadaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObustavaNaknadaTipProvider SqlObustavaNaknadaTipProvider
		{
			get {return ObustavaNaknadaTipProvider as SqlObustavaNaknadaTipProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijskaJedinicaTipProvider"
			
		private SqlOrganizacijskaJedinicaTipProvider innerSqlOrganizacijskaJedinicaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrganizacijskaJedinicaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijskaJedinicaTipProviderBase OrganizacijskaJedinicaTipProvider
		{
			get
			{
				if (innerSqlOrganizacijskaJedinicaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijskaJedinicaTipProvider == null)
						{
							this.innerSqlOrganizacijskaJedinicaTipProvider = new SqlOrganizacijskaJedinicaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijskaJedinicaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijskaJedinicaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijskaJedinicaTipProvider SqlOrganizacijskaJedinicaTipProvider
		{
			get {return OrganizacijskaJedinicaTipProvider as SqlOrganizacijskaJedinicaTipProvider;}
		}
		
		#endregion
		
		
		#region "OSKarticaProvider"
			
		private SqlOSKarticaProvider innerSqlOSKarticaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OSKartica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OSKarticaProviderBase OSKarticaProvider
		{
			get
			{
				if (innerSqlOSKarticaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOSKarticaProvider == null)
						{
							this.innerSqlOSKarticaProvider = new SqlOSKarticaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOSKarticaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOSKarticaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOSKarticaProvider SqlOSKarticaProvider
		{
			get {return OSKarticaProvider as SqlOSKarticaProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijskaJedinicaZiroRacunProvider"
			
		private SqlOrganizacijskaJedinicaZiroRacunProvider innerSqlOrganizacijskaJedinicaZiroRacunProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrganizacijskaJedinicaZiroRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijskaJedinicaZiroRacunProviderBase OrganizacijskaJedinicaZiroRacunProvider
		{
			get
			{
				if (innerSqlOrganizacijskaJedinicaZiroRacunProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijskaJedinicaZiroRacunProvider == null)
						{
							this.innerSqlOrganizacijskaJedinicaZiroRacunProvider = new SqlOrganizacijskaJedinicaZiroRacunProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijskaJedinicaZiroRacunProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijskaJedinicaZiroRacunProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijskaJedinicaZiroRacunProvider SqlOrganizacijskaJedinicaZiroRacunProvider
		{
			get {return OrganizacijskaJedinicaZiroRacunProvider as SqlOrganizacijskaJedinicaZiroRacunProvider;}
		}
		
		#endregion
		
		
		#region "OSGrupaProvider"
			
		private SqlOSGrupaProvider innerSqlOSGrupaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OSGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OSGrupaProviderBase OSGrupaProvider
		{
			get
			{
				if (innerSqlOSGrupaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOSGrupaProvider == null)
						{
							this.innerSqlOSGrupaProvider = new SqlOSGrupaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOSGrupaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOSGrupaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOSGrupaProvider SqlOSGrupaProvider
		{
			get {return OSGrupaProvider as SqlOSGrupaProvider;}
		}
		
		#endregion
		
		
		#region "OsnovaOsiguranjaTipProvider"
			
		private SqlOsnovaOsiguranjaTipProvider innerSqlOsnovaOsiguranjaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OsnovaOsiguranjaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OsnovaOsiguranjaTipProviderBase OsnovaOsiguranjaTipProvider
		{
			get
			{
				if (innerSqlOsnovaOsiguranjaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOsnovaOsiguranjaTipProvider == null)
						{
							this.innerSqlOsnovaOsiguranjaTipProvider = new SqlOsnovaOsiguranjaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOsnovaOsiguranjaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOsnovaOsiguranjaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOsnovaOsiguranjaTipProvider SqlOsnovaOsiguranjaTipProvider
		{
			get {return OsnovaOsiguranjaTipProvider as SqlOsnovaOsiguranjaTipProvider;}
		}
		
		#endregion
		
		
		#region "OrganizacijskaJedinicaProvider"
			
		private SqlOrganizacijskaJedinicaProvider innerSqlOrganizacijskaJedinicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OrganizacijskaJedinica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OrganizacijskaJedinicaProviderBase OrganizacijskaJedinicaProvider
		{
			get
			{
				if (innerSqlOrganizacijskaJedinicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOrganizacijskaJedinicaProvider == null)
						{
							this.innerSqlOrganizacijskaJedinicaProvider = new SqlOrganizacijskaJedinicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOrganizacijskaJedinicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOrganizacijskaJedinicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOrganizacijskaJedinicaProvider SqlOrganizacijskaJedinicaProvider
		{
			get {return OrganizacijskaJedinicaProvider as SqlOrganizacijskaJedinicaProvider;}
		}
		
		#endregion
		
		
		#region "OSAmortizacijskaGrupaProvider"
			
		private SqlOSAmortizacijskaGrupaProvider innerSqlOSAmortizacijskaGrupaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OSAmortizacijskaGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OSAmortizacijskaGrupaProviderBase OSAmortizacijskaGrupaProvider
		{
			get
			{
				if (innerSqlOSAmortizacijskaGrupaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOSAmortizacijskaGrupaProvider == null)
						{
							this.innerSqlOSAmortizacijskaGrupaProvider = new SqlOSAmortizacijskaGrupaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOSAmortizacijskaGrupaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOSAmortizacijskaGrupaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOSAmortizacijskaGrupaProvider SqlOSAmortizacijskaGrupaProvider
		{
			get {return OSAmortizacijskaGrupaProvider as SqlOSAmortizacijskaGrupaProvider;}
		}
		
		#endregion
		
		
		#region "OSAGPromjenaProvider"
			
		private SqlOSAGPromjenaProvider innerSqlOSAGPromjenaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="OSAGPromjena"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override OSAGPromjenaProviderBase OSAGPromjenaProvider
		{
			get
			{
				if (innerSqlOSAGPromjenaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlOSAGPromjenaProvider == null)
						{
							this.innerSqlOSAGPromjenaProvider = new SqlOSAGPromjenaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlOSAGPromjenaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlOSAGPromjenaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlOSAGPromjenaProvider SqlOSAGPromjenaProvider
		{
			get {return OSAGPromjenaProvider as SqlOSAGPromjenaProvider;}
		}
		
		#endregion
		
		
		#region "PutniNalogProvider"
			
		private SqlPutniNalogProvider innerSqlPutniNalogProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PutniNalog"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PutniNalogProviderBase PutniNalogProvider
		{
			get
			{
				if (innerSqlPutniNalogProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPutniNalogProvider == null)
						{
							this.innerSqlPutniNalogProvider = new SqlPutniNalogProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPutniNalogProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPutniNalogProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPutniNalogProvider SqlPutniNalogProvider
		{
			get {return PutniNalogProvider as SqlPutniNalogProvider;}
		}
		
		#endregion
		
		
		#region "PutniNalogAkontacijaProvider"
			
		private SqlPutniNalogAkontacijaProvider innerSqlPutniNalogAkontacijaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PutniNalogAkontacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PutniNalogAkontacijaProviderBase PutniNalogAkontacijaProvider
		{
			get
			{
				if (innerSqlPutniNalogAkontacijaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPutniNalogAkontacijaProvider == null)
						{
							this.innerSqlPutniNalogAkontacijaProvider = new SqlPutniNalogAkontacijaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPutniNalogAkontacijaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPutniNalogAkontacijaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPutniNalogAkontacijaProvider SqlPutniNalogAkontacijaProvider
		{
			get {return PutniNalogAkontacijaProvider as SqlPutniNalogAkontacijaProvider;}
		}
		
		#endregion
		
		
		#region "ValutaProvider"
			
		private SqlValutaProvider innerSqlValutaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Valuta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ValutaProviderBase ValutaProvider
		{
			get
			{
				if (innerSqlValutaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlValutaProvider == null)
						{
							this.innerSqlValutaProvider = new SqlValutaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlValutaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlValutaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlValutaProvider SqlValutaProvider
		{
			get {return ValutaProvider as SqlValutaProvider;}
		}
		
		#endregion
		
		
		#region "PutniNalogStavkaDnevnicaProvider"
			
		private SqlPutniNalogStavkaDnevnicaProvider innerSqlPutniNalogStavkaDnevnicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PutniNalogStavkaDnevnica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PutniNalogStavkaDnevnicaProviderBase PutniNalogStavkaDnevnicaProvider
		{
			get
			{
				if (innerSqlPutniNalogStavkaDnevnicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPutniNalogStavkaDnevnicaProvider == null)
						{
							this.innerSqlPutniNalogStavkaDnevnicaProvider = new SqlPutniNalogStavkaDnevnicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPutniNalogStavkaDnevnicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPutniNalogStavkaDnevnicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPutniNalogStavkaDnevnicaProvider SqlPutniNalogStavkaDnevnicaProvider
		{
			get {return PutniNalogStavkaDnevnicaProvider as SqlPutniNalogStavkaDnevnicaProvider;}
		}
		
		#endregion
		
		
		#region "ReportProvider"
			
		private SqlReportProvider innerSqlReportProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Report"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ReportProviderBase ReportProvider
		{
			get
			{
				if (innerSqlReportProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlReportProvider == null)
						{
							this.innerSqlReportProvider = new SqlReportProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlReportProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlReportProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlReportProvider SqlReportProvider
		{
			get {return ReportProvider as SqlReportProvider;}
		}
		
		#endregion
		
		
		#region "SklDZahtijevStavkeProvider"
			
		private SqlSklDZahtijevStavkeProvider innerSqlSklDZahtijevStavkeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="SklDZahtijevStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SklDZahtijevStavkeProviderBase SklDZahtijevStavkeProvider
		{
			get
			{
				if (innerSqlSklDZahtijevStavkeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSklDZahtijevStavkeProvider == null)
						{
							this.innerSqlSklDZahtijevStavkeProvider = new SqlSklDZahtijevStavkeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSklDZahtijevStavkeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlSklDZahtijevStavkeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSklDZahtijevStavkeProvider SqlSklDZahtijevStavkeProvider
		{
			get {return SklDZahtijevStavkeProvider as SqlSklDZahtijevStavkeProvider;}
		}
		
		#endregion
		
		
		#region "SklDLagerProvider"
			
		private SqlSklDLagerProvider innerSqlSklDLagerProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="SklDLager"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SklDLagerProviderBase SklDLagerProvider
		{
			get
			{
				if (innerSqlSklDLagerProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSklDLagerProvider == null)
						{
							this.innerSqlSklDLagerProvider = new SqlSklDLagerProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSklDLagerProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlSklDLagerProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSklDLagerProvider SqlSklDLagerProvider
		{
			get {return SklDLagerProvider as SqlSklDLagerProvider;}
		}
		
		#endregion
		
		
		#region "SifarnikTipProvider"
			
		private SqlSifarnikTipProvider innerSqlSifarnikTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="SifarnikTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SifarnikTipProviderBase SifarnikTipProvider
		{
			get
			{
				if (innerSqlSifarnikTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSifarnikTipProvider == null)
						{
							this.innerSqlSifarnikTipProvider = new SqlSifarnikTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSifarnikTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlSifarnikTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSifarnikTipProvider SqlSifarnikTipProvider
		{
			get {return SifarnikTipProvider as SqlSifarnikTipProvider;}
		}
		
		#endregion
		
		
		#region "SklDZahtjevGlavaProvider"
			
		private SqlSklDZahtjevGlavaProvider innerSqlSklDZahtjevGlavaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="SklDZahtjevGlava"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SklDZahtjevGlavaProviderBase SklDZahtjevGlavaProvider
		{
			get
			{
				if (innerSqlSklDZahtjevGlavaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSklDZahtjevGlavaProvider == null)
						{
							this.innerSqlSklDZahtjevGlavaProvider = new SqlSklDZahtjevGlavaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSklDZahtjevGlavaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlSklDZahtjevGlavaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSklDZahtjevGlavaProvider SqlSklDZahtjevGlavaProvider
		{
			get {return SklDZahtjevGlavaProvider as SqlSklDZahtjevGlavaProvider;}
		}
		
		#endregion
		
		
		#region "SifarnikProvider"
			
		private SqlSifarnikProvider innerSqlSifarnikProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Sifarnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override SifarnikProviderBase SifarnikProvider
		{
			get
			{
				if (innerSqlSifarnikProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlSifarnikProvider == null)
						{
							this.innerSqlSifarnikProvider = new SqlSifarnikProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlSifarnikProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlSifarnikProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlSifarnikProvider SqlSifarnikProvider
		{
			get {return SifarnikProvider as SqlSifarnikProvider;}
		}
		
		#endregion
		
		
		#region "TecajValuteProvider"
			
		private SqlTecajValuteProvider innerSqlTecajValuteProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TecajValute"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TecajValuteProviderBase TecajValuteProvider
		{
			get
			{
				if (innerSqlTecajValuteProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTecajValuteProvider == null)
						{
							this.innerSqlTecajValuteProvider = new SqlTecajValuteProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTecajValuteProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlTecajValuteProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTecajValuteProvider SqlTecajValuteProvider
		{
			get {return TecajValuteProvider as SqlTecajValuteProvider;}
		}
		
		#endregion
		
		
		#region "VrstaRaspodjeleProvider"
			
		private SqlVrstaRaspodjeleProvider innerSqlVrstaRaspodjeleProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VrstaRaspodjele"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VrstaRaspodjeleProviderBase VrstaRaspodjeleProvider
		{
			get
			{
				if (innerSqlVrstaRaspodjeleProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVrstaRaspodjeleProvider == null)
						{
							this.innerSqlVrstaRaspodjeleProvider = new SqlVrstaRaspodjeleProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVrstaRaspodjeleProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVrstaRaspodjeleProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVrstaRaspodjeleProvider SqlVrstaRaspodjeleProvider
		{
			get {return VrstaRaspodjeleProvider as SqlVrstaRaspodjeleProvider;}
		}
		
		#endregion
		
		
		#region "VoziloProvider"
			
		private SqlVoziloProvider innerSqlVoziloProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Vozilo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VoziloProviderBase VoziloProvider
		{
			get
			{
				if (innerSqlVoziloProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVoziloProvider == null)
						{
							this.innerSqlVoziloProvider = new SqlVoziloProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVoziloProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVoziloProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVoziloProvider SqlVoziloProvider
		{
			get {return VoziloProvider as SqlVoziloProvider;}
		}
		
		#endregion
		
		
		#region "VirmanProvider"
			
		private SqlVirmanProvider innerSqlVirmanProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Virman"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VirmanProviderBase VirmanProvider
		{
			get
			{
				if (innerSqlVirmanProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVirmanProvider == null)
						{
							this.innerSqlVirmanProvider = new SqlVirmanProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVirmanProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVirmanProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVirmanProvider SqlVirmanProvider
		{
			get {return VirmanProvider as SqlVirmanProvider;}
		}
		
		#endregion
		
		
		#region "VezaProvider"
			
		private SqlVezaProvider innerSqlVezaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Veza"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VezaProviderBase VezaProvider
		{
			get
			{
				if (innerSqlVezaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVezaProvider == null)
						{
							this.innerSqlVezaProvider = new SqlVezaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVezaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVezaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVezaProvider SqlVezaProvider
		{
			get {return VezaProvider as SqlVezaProvider;}
		}
		
		#endregion
		
		
		#region "TipIspisaProvider"
			
		private SqlTipIspisaProvider innerSqlTipIspisaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="TipIspisa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override TipIspisaProviderBase TipIspisaProvider
		{
			get
			{
				if (innerSqlTipIspisaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlTipIspisaProvider == null)
						{
							this.innerSqlTipIspisaProvider = new SqlTipIspisaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlTipIspisaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlTipIspisaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlTipIspisaProvider SqlTipIspisaProvider
		{
			get {return TipIspisaProvider as SqlTipIspisaProvider;}
		}
		
		#endregion
		
		
		#region "ShemaKnjizenjeNazivKolonaProvider"
			
		private SqlShemaKnjizenjeNazivKolonaProvider innerSqlShemaKnjizenjeNazivKolonaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ShemaKnjizenjeNazivKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ShemaKnjizenjeNazivKolonaProviderBase ShemaKnjizenjeNazivKolonaProvider
		{
			get
			{
				if (innerSqlShemaKnjizenjeNazivKolonaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlShemaKnjizenjeNazivKolonaProvider == null)
						{
							this.innerSqlShemaKnjizenjeNazivKolonaProvider = new SqlShemaKnjizenjeNazivKolonaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlShemaKnjizenjeNazivKolonaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlShemaKnjizenjeNazivKolonaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlShemaKnjizenjeNazivKolonaProvider SqlShemaKnjizenjeNazivKolonaProvider
		{
			get {return ShemaKnjizenjeNazivKolonaProvider as SqlShemaKnjizenjeNazivKolonaProvider;}
		}
		
		#endregion
		
		
		#region "ShemaKnjizenjaRobnoProvider"
			
		private SqlShemaKnjizenjaRobnoProvider innerSqlShemaKnjizenjaRobnoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ShemaKnjizenjaRobno"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ShemaKnjizenjaRobnoProviderBase ShemaKnjizenjaRobnoProvider
		{
			get
			{
				if (innerSqlShemaKnjizenjaRobnoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlShemaKnjizenjaRobnoProvider == null)
						{
							this.innerSqlShemaKnjizenjaRobnoProvider = new SqlShemaKnjizenjaRobnoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlShemaKnjizenjaRobnoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlShemaKnjizenjaRobnoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlShemaKnjizenjaRobnoProvider SqlShemaKnjizenjaRobnoProvider
		{
			get {return ShemaKnjizenjaRobnoProvider as SqlShemaKnjizenjaRobnoProvider;}
		}
		
		#endregion
		
		
		#region "ReportPivotsProvider"
			
		private SqlReportPivotsProvider innerSqlReportPivotsProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ReportPivots"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ReportPivotsProviderBase ReportPivotsProvider
		{
			get
			{
				if (innerSqlReportPivotsProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlReportPivotsProvider == null)
						{
							this.innerSqlReportPivotsProvider = new SqlReportPivotsProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlReportPivotsProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlReportPivotsProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlReportPivotsProvider SqlReportPivotsProvider
		{
			get {return ReportPivotsProvider as SqlReportPivotsProvider;}
		}
		
		#endregion
		
		
		#region "RadniNalogVezaProvider"
			
		private SqlRadniNalogVezaProvider innerSqlRadniNalogVezaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="RadniNalogVeza"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RadniNalogVezaProviderBase RadniNalogVezaProvider
		{
			get
			{
				if (innerSqlRadniNalogVezaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRadniNalogVezaProvider == null)
						{
							this.innerSqlRadniNalogVezaProvider = new SqlRadniNalogVezaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRadniNalogVezaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRadniNalogVezaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRadniNalogVezaProvider SqlRadniNalogVezaProvider
		{
			get {return RadniNalogVezaProvider as SqlRadniNalogVezaProvider;}
		}
		
		#endregion
		
		
		#region "RabatProvider"
			
		private SqlRabatProvider innerSqlRabatProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Rabat"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RabatProviderBase RabatProvider
		{
			get
			{
				if (innerSqlRabatProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRabatProvider == null)
						{
							this.innerSqlRabatProvider = new SqlRabatProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRabatProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRabatProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRabatProvider SqlRabatProvider
		{
			get {return RabatProvider as SqlRabatProvider;}
		}
		
		#endregion
		
		
		#region "PutniNalogStavkaOstaloProvider"
			
		private SqlPutniNalogStavkaOstaloProvider innerSqlPutniNalogStavkaOstaloProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PutniNalogStavkaOstalo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PutniNalogStavkaOstaloProviderBase PutniNalogStavkaOstaloProvider
		{
			get
			{
				if (innerSqlPutniNalogStavkaOstaloProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPutniNalogStavkaOstaloProvider == null)
						{
							this.innerSqlPutniNalogStavkaOstaloProvider = new SqlPutniNalogStavkaOstaloProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPutniNalogStavkaOstaloProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPutniNalogStavkaOstaloProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPutniNalogStavkaOstaloProvider SqlPutniNalogStavkaOstaloProvider
		{
			get {return PutniNalogStavkaOstaloProvider as SqlPutniNalogStavkaOstaloProvider;}
		}
		
		#endregion
		
		
		#region "PutniNalogStavkaPrijevozProvider"
			
		private SqlPutniNalogStavkaPrijevozProvider innerSqlPutniNalogStavkaPrijevozProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="PutniNalogStavkaPrijevoz"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override PutniNalogStavkaPrijevozProviderBase PutniNalogStavkaPrijevozProvider
		{
			get
			{
				if (innerSqlPutniNalogStavkaPrijevozProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlPutniNalogStavkaPrijevozProvider == null)
						{
							this.innerSqlPutniNalogStavkaPrijevozProvider = new SqlPutniNalogStavkaPrijevozProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlPutniNalogStavkaPrijevozProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlPutniNalogStavkaPrijevozProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlPutniNalogStavkaPrijevozProvider SqlPutniNalogStavkaPrijevozProvider
		{
			get {return PutniNalogStavkaPrijevozProvider as SqlPutniNalogStavkaPrijevozProvider;}
		}
		
		#endregion
		
		
		#region "RadniOdnosTipProvider"
			
		private SqlRadniOdnosTipProvider innerSqlRadniOdnosTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="RadniOdnosTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RadniOdnosTipProviderBase RadniOdnosTipProvider
		{
			get
			{
				if (innerSqlRadniOdnosTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRadniOdnosTipProvider == null)
						{
							this.innerSqlRadniOdnosTipProvider = new SqlRadniOdnosTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRadniOdnosTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRadniOdnosTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRadniOdnosTipProvider SqlRadniOdnosTipProvider
		{
			get {return RadniOdnosTipProvider as SqlRadniOdnosTipProvider;}
		}
		
		#endregion
		
		
		#region "RabatSpecProvider"
			
		private SqlRabatSpecProvider innerSqlRabatSpecProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="RabatSpec"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RabatSpecProviderBase RabatSpecProvider
		{
			get
			{
				if (innerSqlRabatSpecProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRabatSpecProvider == null)
						{
							this.innerSqlRabatSpecProvider = new SqlRabatSpecProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRabatSpecProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRabatSpecProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRabatSpecProvider SqlRabatSpecProvider
		{
			get {return RabatSpecProvider as SqlRabatSpecProvider;}
		}
		
		#endregion
		
		
		#region "RadnoMjestoProvider"
			
		private SqlRadnoMjestoProvider innerSqlRadnoMjestoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="RadnoMjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RadnoMjestoProviderBase RadnoMjestoProvider
		{
			get
			{
				if (innerSqlRadnoMjestoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRadnoMjestoProvider == null)
						{
							this.innerSqlRadnoMjestoProvider = new SqlRadnoMjestoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRadnoMjestoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRadnoMjestoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRadnoMjestoProvider SqlRadnoMjestoProvider
		{
			get {return RadnoMjestoProvider as SqlRadnoMjestoProvider;}
		}
		
		#endregion
		
		
		#region "ReportKolumnaTipProvider"
			
		private SqlReportKolumnaTipProvider innerSqlReportKolumnaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ReportKolumnaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ReportKolumnaTipProviderBase ReportKolumnaTipProvider
		{
			get
			{
				if (innerSqlReportKolumnaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlReportKolumnaTipProvider == null)
						{
							this.innerSqlReportKolumnaTipProvider = new SqlReportKolumnaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlReportKolumnaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlReportKolumnaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlReportKolumnaTipProvider SqlReportKolumnaTipProvider
		{
			get {return ReportKolumnaTipProvider as SqlReportKolumnaTipProvider;}
		}
		
		#endregion
		
		
		#region "ReportKolumnaProvider"
			
		private SqlReportKolumnaProvider innerSqlReportKolumnaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ReportKolumna"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ReportKolumnaProviderBase ReportKolumnaProvider
		{
			get
			{
				if (innerSqlReportKolumnaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlReportKolumnaProvider == null)
						{
							this.innerSqlReportKolumnaProvider = new SqlReportKolumnaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlReportKolumnaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlReportKolumnaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlReportKolumnaProvider SqlReportKolumnaProvider
		{
			get {return ReportKolumnaProvider as SqlReportKolumnaProvider;}
		}
		
		#endregion
		
		
		#region "ReportiServerProvider"
			
		private SqlReportiServerProvider innerSqlReportiServerProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ReportiServer"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ReportiServerProviderBase ReportiServerProvider
		{
			get
			{
				if (innerSqlReportiServerProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlReportiServerProvider == null)
						{
							this.innerSqlReportiServerProvider = new SqlReportiServerProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlReportiServerProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlReportiServerProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlReportiServerProvider SqlReportiServerProvider
		{
			get {return ReportiServerProvider as SqlReportiServerProvider;}
		}
		
		#endregion
		
		
		#region "RazdobljeStopaProvider"
			
		private SqlRazdobljeStopaProvider innerSqlRazdobljeStopaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="RazdobljeStopa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RazdobljeStopaProviderBase RazdobljeStopaProvider
		{
			get
			{
				if (innerSqlRazdobljeStopaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRazdobljeStopaProvider == null)
						{
							this.innerSqlRazdobljeStopaProvider = new SqlRazdobljeStopaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRazdobljeStopaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRazdobljeStopaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRazdobljeStopaProvider SqlRazdobljeStopaProvider
		{
			get {return RazdobljeStopaProvider as SqlRazdobljeStopaProvider;}
		}
		
		#endregion
		
		
		#region "RazdobljeProvider"
			
		private SqlRazdobljeProvider innerSqlRazdobljeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Razdoblje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override RazdobljeProviderBase RazdobljeProvider
		{
			get
			{
				if (innerSqlRazdobljeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlRazdobljeProvider == null)
						{
							this.innerSqlRazdobljeProvider = new SqlRazdobljeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlRazdobljeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlRazdobljeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlRazdobljeProvider SqlRazdobljeProvider
		{
			get {return RazdobljeProvider as SqlRazdobljeProvider;}
		}
		
		#endregion
		
		
		#region "ObracunVirmanProvider"
			
		private SqlObracunVirmanProvider innerSqlObracunVirmanProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunVirman"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunVirmanProviderBase ObracunVirmanProvider
		{
			get
			{
				if (innerSqlObracunVirmanProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunVirmanProvider == null)
						{
							this.innerSqlObracunVirmanProvider = new SqlObracunVirmanProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunVirmanProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunVirmanProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunVirmanProvider SqlObracunVirmanProvider
		{
			get {return ObracunVirmanProvider as SqlObracunVirmanProvider;}
		}
		
		#endregion
		
		
		#region "ObracunRSMProvider"
			
		private SqlObracunRSMProvider innerSqlObracunRSMProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunRSM"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunRSMProviderBase ObracunRSMProvider
		{
			get
			{
				if (innerSqlObracunRSMProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunRSMProvider == null)
						{
							this.innerSqlObracunRSMProvider = new SqlObracunRSMProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunRSMProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunRSMProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunRSMProvider SqlObracunRSMProvider
		{
			get {return ObracunRSMProvider as SqlObracunRSMProvider;}
		}
		
		#endregion
		
		
		#region "DokumentProvider"
			
		private SqlDokumentProvider innerSqlDokumentProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Dokument"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentProviderBase DokumentProvider
		{
			get
			{
				if (innerSqlDokumentProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentProvider == null)
						{
							this.innerSqlDokumentProvider = new SqlDokumentProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentProvider SqlDokumentProvider
		{
			get {return DokumentProvider as SqlDokumentProvider;}
		}
		
		#endregion
		
		
		#region "DokumentPlacanjeProvider"
			
		private SqlDokumentPlacanjeProvider innerSqlDokumentPlacanjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentPlacanje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentPlacanjeProviderBase DokumentPlacanjeProvider
		{
			get
			{
				if (innerSqlDokumentPlacanjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentPlacanjeProvider == null)
						{
							this.innerSqlDokumentPlacanjeProvider = new SqlDokumentPlacanjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentPlacanjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentPlacanjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentPlacanjeProvider SqlDokumentPlacanjeProvider
		{
			get {return DokumentPlacanjeProvider as SqlDokumentPlacanjeProvider;}
		}
		
		#endregion
		
		
		#region "ObracunOsobaPrimanjeProvider"
			
		private SqlObracunOsobaPrimanjeProvider innerSqlObracunOsobaPrimanjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunOsobaPrimanje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunOsobaPrimanjeProviderBase ObracunOsobaPrimanjeProvider
		{
			get
			{
				if (innerSqlObracunOsobaPrimanjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunOsobaPrimanjeProvider == null)
						{
							this.innerSqlObracunOsobaPrimanjeProvider = new SqlObracunOsobaPrimanjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunOsobaPrimanjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunOsobaPrimanjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunOsobaPrimanjeProvider SqlObracunOsobaPrimanjeProvider
		{
			get {return ObracunOsobaPrimanjeProvider as SqlObracunOsobaPrimanjeProvider;}
		}
		
		#endregion
		
		
		#region "DokumentTipProvider"
			
		private SqlDokumentTipProvider innerSqlDokumentTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentTipProviderBase DokumentTipProvider
		{
			get
			{
				if (innerSqlDokumentTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentTipProvider == null)
						{
							this.innerSqlDokumentTipProvider = new SqlDokumentTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentTipProvider SqlDokumentTipProvider
		{
			get {return DokumentTipProvider as SqlDokumentTipProvider;}
		}
		
		#endregion
		
		
		#region "DjelatnikProvider"
			
		private SqlDjelatnikProvider innerSqlDjelatnikProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Djelatnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DjelatnikProviderBase DjelatnikProvider
		{
			get
			{
				if (innerSqlDjelatnikProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDjelatnikProvider == null)
						{
							this.innerSqlDjelatnikProvider = new SqlDjelatnikProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDjelatnikProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDjelatnikProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDjelatnikProvider SqlDjelatnikProvider
		{
			get {return DjelatnikProvider as SqlDjelatnikProvider;}
		}
		
		#endregion
		
		
		#region "DokumentDodatakProvider"
			
		private SqlDokumentDodatakProvider innerSqlDokumentDodatakProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentDodatak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentDodatakProviderBase DokumentDodatakProvider
		{
			get
			{
				if (innerSqlDokumentDodatakProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentDodatakProvider == null)
						{
							this.innerSqlDokumentDodatakProvider = new SqlDokumentDodatakProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentDodatakProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentDodatakProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentDodatakProvider SqlDokumentDodatakProvider
		{
			get {return DokumentDodatakProvider as SqlDokumentDodatakProvider;}
		}
		
		#endregion
		
		
		#region "DokumentStavkaProvider"
			
		private SqlDokumentStavkaProvider innerSqlDokumentStavkaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentStavkaProviderBase DokumentStavkaProvider
		{
			get
			{
				if (innerSqlDokumentStavkaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentStavkaProvider == null)
						{
							this.innerSqlDokumentStavkaProvider = new SqlDokumentStavkaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentStavkaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentStavkaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentStavkaProvider SqlDokumentStavkaProvider
		{
			get {return DokumentStavkaProvider as SqlDokumentStavkaProvider;}
		}
		
		#endregion
		
		
		#region "DnevnicaProvider"
			
		private SqlDnevnicaProvider innerSqlDnevnicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Dnevnica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DnevnicaProviderBase DnevnicaProvider
		{
			get
			{
				if (innerSqlDnevnicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDnevnicaProvider == null)
						{
							this.innerSqlDnevnicaProvider = new SqlDnevnicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDnevnicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDnevnicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDnevnicaProvider SqlDnevnicaProvider
		{
			get {return DnevnicaProvider as SqlDnevnicaProvider;}
		}
		
		#endregion
		
		
		#region "DjelatnikInGrupaProvider"
			
		private SqlDjelatnikInGrupaProvider innerSqlDjelatnikInGrupaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DjelatnikInGrupa"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DjelatnikInGrupaProviderBase DjelatnikInGrupaProvider
		{
			get
			{
				if (innerSqlDjelatnikInGrupaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDjelatnikInGrupaProvider == null)
						{
							this.innerSqlDjelatnikInGrupaProvider = new SqlDjelatnikInGrupaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDjelatnikInGrupaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDjelatnikInGrupaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDjelatnikInGrupaProvider SqlDjelatnikInGrupaProvider
		{
			get {return DjelatnikInGrupaProvider as SqlDjelatnikInGrupaProvider;}
		}
		
		#endregion
		
		
		#region "DokumentStavkaOpisProvider"
			
		private SqlDokumentStavkaOpisProvider innerSqlDokumentStavkaOpisProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentStavkaOpis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentStavkaOpisProviderBase DokumentStavkaOpisProvider
		{
			get
			{
				if (innerSqlDokumentStavkaOpisProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentStavkaOpisProvider == null)
						{
							this.innerSqlDokumentStavkaOpisProvider = new SqlDokumentStavkaOpisProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentStavkaOpisProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentStavkaOpisProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentStavkaOpisProvider SqlDokumentStavkaOpisProvider
		{
			get {return DokumentStavkaOpisProvider as SqlDokumentStavkaOpisProvider;}
		}
		
		#endregion
		
		
		#region "DokumentZaglavljeSpecTipProvider"
			
		private SqlDokumentZaglavljeSpecTipProvider innerSqlDokumentZaglavljeSpecTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentZaglavljeSpecTipProviderBase DokumentZaglavljeSpecTipProvider
		{
			get
			{
				if (innerSqlDokumentZaglavljeSpecTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentZaglavljeSpecTipProvider == null)
						{
							this.innerSqlDokumentZaglavljeSpecTipProvider = new SqlDokumentZaglavljeSpecTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentZaglavljeSpecTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentZaglavljeSpecTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentZaglavljeSpecTipProvider SqlDokumentZaglavljeSpecTipProvider
		{
			get {return DokumentZaglavljeSpecTipProvider as SqlDokumentZaglavljeSpecTipProvider;}
		}
		
		#endregion
		
		
		#region "DokumentZaglavljeSpecPostavkeProvider"
			
		private SqlDokumentZaglavljeSpecPostavkeProvider innerSqlDokumentZaglavljeSpecPostavkeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecPostavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentZaglavljeSpecPostavkeProviderBase DokumentZaglavljeSpecPostavkeProvider
		{
			get
			{
				if (innerSqlDokumentZaglavljeSpecPostavkeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentZaglavljeSpecPostavkeProvider == null)
						{
							this.innerSqlDokumentZaglavljeSpecPostavkeProvider = new SqlDokumentZaglavljeSpecPostavkeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentZaglavljeSpecPostavkeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentZaglavljeSpecPostavkeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentZaglavljeSpecPostavkeProvider SqlDokumentZaglavljeSpecPostavkeProvider
		{
			get {return DokumentZaglavljeSpecPostavkeProvider as SqlDokumentZaglavljeSpecPostavkeProvider;}
		}
		
		#endregion
		
		
		#region "GrupaParametraProvider"
			
		private SqlGrupaParametraProvider innerSqlGrupaParametraProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GrupaParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GrupaParametraProviderBase GrupaParametraProvider
		{
			get
			{
				if (innerSqlGrupaParametraProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGrupaParametraProvider == null)
						{
							this.innerSqlGrupaParametraProvider = new SqlGrupaParametraProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGrupaParametraProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlGrupaParametraProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGrupaParametraProvider SqlGrupaParametraProvider
		{
			get {return GrupaParametraProvider as SqlGrupaParametraProvider;}
		}
		
		#endregion
		
		
		#region "DokumentZaglavljeSpecDokTipProvider"
			
		private SqlDokumentZaglavljeSpecDokTipProvider innerSqlDokumentZaglavljeSpecDokTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentZaglavljeSpecDokTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentZaglavljeSpecDokTipProviderBase DokumentZaglavljeSpecDokTipProvider
		{
			get
			{
				if (innerSqlDokumentZaglavljeSpecDokTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentZaglavljeSpecDokTipProvider == null)
						{
							this.innerSqlDokumentZaglavljeSpecDokTipProvider = new SqlDokumentZaglavljeSpecDokTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentZaglavljeSpecDokTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentZaglavljeSpecDokTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentZaglavljeSpecDokTipProvider SqlDokumentZaglavljeSpecDokTipProvider
		{
			get {return DokumentZaglavljeSpecDokTipProvider as SqlDokumentZaglavljeSpecDokTipProvider;}
		}
		
		#endregion
		
		
		#region "DokumentZaglavljeProvider"
			
		private SqlDokumentZaglavljeProvider innerSqlDokumentZaglavljeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DokumentZaglavlje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DokumentZaglavljeProviderBase DokumentZaglavljeProvider
		{
			get
			{
				if (innerSqlDokumentZaglavljeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDokumentZaglavljeProvider == null)
						{
							this.innerSqlDokumentZaglavljeProvider = new SqlDokumentZaglavljeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDokumentZaglavljeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDokumentZaglavljeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDokumentZaglavljeProvider SqlDokumentZaglavljeProvider
		{
			get {return DokumentZaglavljeProvider as SqlDokumentZaglavljeProvider;}
		}
		
		#endregion
		
		
		#region "DefParametraProvider"
			
		private SqlDefParametraProvider innerSqlDefParametraProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="DefParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override DefParametraProviderBase DefParametraProvider
		{
			get
			{
				if (innerSqlDefParametraProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlDefParametraProvider == null)
						{
							this.innerSqlDefParametraProvider = new SqlDefParametraProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlDefParametraProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlDefParametraProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlDefParametraProvider SqlDefParametraProvider
		{
			get {return DefParametraProvider as SqlDefParametraProvider;}
		}
		
		#endregion
		
		
		#region "BlagdanProvider"
			
		private SqlBlagdanProvider innerSqlBlagdanProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Blagdan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BlagdanProviderBase BlagdanProvider
		{
			get
			{
				if (innerSqlBlagdanProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBlagdanProvider == null)
						{
							this.innerSqlBlagdanProvider = new SqlBlagdanProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBlagdanProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlBlagdanProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBlagdanProvider SqlBlagdanProvider
		{
			get {return BlagdanProvider as SqlBlagdanProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklMjeraProvider"
			
		private SqlArtiklMjeraProvider innerSqlArtiklMjeraProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklMjera"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklMjeraProviderBase ArtiklMjeraProvider
		{
			get
			{
				if (innerSqlArtiklMjeraProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklMjeraProvider == null)
						{
							this.innerSqlArtiklMjeraProvider = new SqlArtiklMjeraProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklMjeraProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklMjeraProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklMjeraProvider SqlArtiklMjeraProvider
		{
			get {return ArtiklMjeraProvider as SqlArtiklMjeraProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklKategorijaProvider"
			
		private SqlArtiklKategorijaProvider innerSqlArtiklKategorijaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklKategorija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklKategorijaProviderBase ArtiklKategorijaProvider
		{
			get
			{
				if (innerSqlArtiklKategorijaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklKategorijaProvider == null)
						{
							this.innerSqlArtiklKategorijaProvider = new SqlArtiklKategorijaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklKategorijaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklKategorijaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklKategorijaProvider SqlArtiklKategorijaProvider
		{
			get {return ArtiklKategorijaProvider as SqlArtiklKategorijaProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklProvider"
			
		private SqlArtiklProvider innerSqlArtiklProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Artikl"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklProviderBase ArtiklProvider
		{
			get
			{
				if (innerSqlArtiklProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklProvider == null)
						{
							this.innerSqlArtiklProvider = new SqlArtiklProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklProvider SqlArtiklProvider
		{
			get {return ArtiklProvider as SqlArtiklProvider;}
		}
		
		#endregion
		
		
		#region "AdresaTipProvider"
			
		private SqlAdresaTipProvider innerSqlAdresaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="AdresaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override AdresaTipProviderBase AdresaTipProvider
		{
			get
			{
				if (innerSqlAdresaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlAdresaTipProvider == null)
						{
							this.innerSqlAdresaTipProvider = new SqlAdresaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlAdresaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlAdresaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlAdresaTipProvider SqlAdresaTipProvider
		{
			get {return AdresaTipProvider as SqlAdresaTipProvider;}
		}
		
		#endregion
		
		
		#region "_PostavkeServeraProvider"
			
		private Sql_PostavkeServeraProvider innerSql_PostavkeServeraProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="_PostavkeServera"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override _PostavkeServeraProviderBase _PostavkeServeraProvider
		{
			get
			{
				if (innerSql_PostavkeServeraProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSql_PostavkeServeraProvider == null)
						{
							this.innerSql_PostavkeServeraProvider = new Sql_PostavkeServeraProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSql_PostavkeServeraProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="Sql_PostavkeServeraProvider"/>.
		/// </summary>
		/// <value></value>
		public Sql_PostavkeServeraProvider Sql_PostavkeServeraProvider
		{
			get {return _PostavkeServeraProvider as Sql_PostavkeServeraProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklSpecifikacijaTipProvider"
			
		private SqlArtiklSpecifikacijaTipProvider innerSqlArtiklSpecifikacijaTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklSpecifikacijaTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklSpecifikacijaTipProviderBase ArtiklSpecifikacijaTipProvider
		{
			get
			{
				if (innerSqlArtiklSpecifikacijaTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklSpecifikacijaTipProvider == null)
						{
							this.innerSqlArtiklSpecifikacijaTipProvider = new SqlArtiklSpecifikacijaTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklSpecifikacijaTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklSpecifikacijaTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklSpecifikacijaTipProvider SqlArtiklSpecifikacijaTipProvider
		{
			get {return ArtiklSpecifikacijaTipProvider as SqlArtiklSpecifikacijaTipProvider;}
		}
		
		#endregion
		
		
		#region "BlagajnaProvider"
			
		private SqlBlagajnaProvider innerSqlBlagajnaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Blagajna"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BlagajnaProviderBase BlagajnaProvider
		{
			get
			{
				if (innerSqlBlagajnaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBlagajnaProvider == null)
						{
							this.innerSqlBlagajnaProvider = new SqlBlagajnaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBlagajnaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlBlagajnaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBlagajnaProvider SqlBlagajnaProvider
		{
			get {return BlagajnaProvider as SqlBlagajnaProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklStatusProvider"
			
		private SqlArtiklStatusProvider innerSqlArtiklStatusProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklStatus"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklStatusProviderBase ArtiklStatusProvider
		{
			get
			{
				if (innerSqlArtiklStatusProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklStatusProvider == null)
						{
							this.innerSqlArtiklStatusProvider = new SqlArtiklStatusProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklStatusProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklStatusProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklStatusProvider SqlArtiklStatusProvider
		{
			get {return ArtiklStatusProvider as SqlArtiklStatusProvider;}
		}
		
		#endregion
		
		
		#region "BlagajnaIzvjestajProvider"
			
		private SqlBlagajnaIzvjestajProvider innerSqlBlagajnaIzvjestajProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BlagajnaIzvjestaj"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BlagajnaIzvjestajProviderBase BlagajnaIzvjestajProvider
		{
			get
			{
				if (innerSqlBlagajnaIzvjestajProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBlagajnaIzvjestajProvider == null)
						{
							this.innerSqlBlagajnaIzvjestajProvider = new SqlBlagajnaIzvjestajProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBlagajnaIzvjestajProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlBlagajnaIzvjestajProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBlagajnaIzvjestajProvider SqlBlagajnaIzvjestajProvider
		{
			get {return BlagajnaIzvjestajProvider as SqlBlagajnaIzvjestajProvider;}
		}
		
		#endregion
		
		
		#region "BlagajnaStavkaProvider"
			
		private SqlBlagajnaStavkaProvider innerSqlBlagajnaStavkaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="BlagajnaStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BlagajnaStavkaProviderBase BlagajnaStavkaProvider
		{
			get
			{
				if (innerSqlBlagajnaStavkaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBlagajnaStavkaProvider == null)
						{
							this.innerSqlBlagajnaStavkaProvider = new SqlBlagajnaStavkaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBlagajnaStavkaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlBlagajnaStavkaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBlagajnaStavkaProvider SqlBlagajnaStavkaProvider
		{
			get {return BlagajnaStavkaProvider as SqlBlagajnaStavkaProvider;}
		}
		
		#endregion
		
		
		#region "BankaProvider"
			
		private SqlBankaProvider innerSqlBankaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Banka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override BankaProviderBase BankaProvider
		{
			get
			{
				if (innerSqlBankaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlBankaProvider == null)
						{
							this.innerSqlBankaProvider = new SqlBankaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlBankaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlBankaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlBankaProvider SqlBankaProvider
		{
			get {return BankaProvider as SqlBankaProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklSpecifikacijaProvider"
			
		private SqlArtiklSpecifikacijaProvider innerSqlArtiklSpecifikacijaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklSpecifikacija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklSpecifikacijaProviderBase ArtiklSpecifikacijaProvider
		{
			get
			{
				if (innerSqlArtiklSpecifikacijaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklSpecifikacijaProvider == null)
						{
							this.innerSqlArtiklSpecifikacijaProvider = new SqlArtiklSpecifikacijaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklSpecifikacijaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklSpecifikacijaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklSpecifikacijaProvider SqlArtiklSpecifikacijaProvider
		{
			get {return ArtiklSpecifikacijaProvider as SqlArtiklSpecifikacijaProvider;}
		}
		
		#endregion
		
		
		#region "GrupaDjelatnikProvider"
			
		private SqlGrupaDjelatnikProvider innerSqlGrupaDjelatnikProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GrupaDjelatnik"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GrupaDjelatnikProviderBase GrupaDjelatnikProvider
		{
			get
			{
				if (innerSqlGrupaDjelatnikProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGrupaDjelatnikProvider == null)
						{
							this.innerSqlGrupaDjelatnikProvider = new SqlGrupaDjelatnikProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGrupaDjelatnikProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlGrupaDjelatnikProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGrupaDjelatnikProvider SqlGrupaDjelatnikProvider
		{
			get {return GrupaDjelatnikProvider as SqlGrupaDjelatnikProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklSpecifikacijaStaticTableProvider"
			
		private SqlArtiklSpecifikacijaStaticTableProvider innerSqlArtiklSpecifikacijaStaticTableProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklSpecifikacijaStaticTable"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklSpecifikacijaStaticTableProviderBase ArtiklSpecifikacijaStaticTableProvider
		{
			get
			{
				if (innerSqlArtiklSpecifikacijaStaticTableProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklSpecifikacijaStaticTableProvider == null)
						{
							this.innerSqlArtiklSpecifikacijaStaticTableProvider = new SqlArtiklSpecifikacijaStaticTableProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklSpecifikacijaStaticTableProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklSpecifikacijaStaticTableProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklSpecifikacijaStaticTableProvider SqlArtiklSpecifikacijaStaticTableProvider
		{
			get {return ArtiklSpecifikacijaStaticTableProvider as SqlArtiklSpecifikacijaStaticTableProvider;}
		}
		
		#endregion
		
		
		#region "ArtiklVrijednostiProvider"
			
		private SqlArtiklVrijednostiProvider innerSqlArtiklVrijednostiProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ArtiklVrijednosti"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ArtiklVrijednostiProviderBase ArtiklVrijednostiProvider
		{
			get
			{
				if (innerSqlArtiklVrijednostiProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlArtiklVrijednostiProvider == null)
						{
							this.innerSqlArtiklVrijednostiProvider = new SqlArtiklVrijednostiProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlArtiklVrijednostiProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlArtiklVrijednostiProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlArtiklVrijednostiProvider SqlArtiklVrijednostiProvider
		{
			get {return ArtiklVrijednostiProvider as SqlArtiklVrijednostiProvider;}
		}
		
		#endregion
		
		
		#region "NetoBrutoProvider"
			
		private SqlNetoBrutoProvider innerSqlNetoBrutoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NetoBruto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NetoBrutoProviderBase NetoBrutoProvider
		{
			get
			{
				if (innerSqlNetoBrutoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNetoBrutoProvider == null)
						{
							this.innerSqlNetoBrutoProvider = new SqlNetoBrutoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNetoBrutoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlNetoBrutoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNetoBrutoProvider SqlNetoBrutoProvider
		{
			get {return NetoBrutoProvider as SqlNetoBrutoProvider;}
		}
		
		#endregion
		
		
		#region "MjestoTipProvider"
			
		private SqlMjestoTipProvider innerSqlMjestoTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="MjestoTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MjestoTipProviderBase MjestoTipProvider
		{
			get
			{
				if (innerSqlMjestoTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMjestoTipProvider == null)
						{
							this.innerSqlMjestoTipProvider = new SqlMjestoTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMjestoTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlMjestoTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMjestoTipProvider SqlMjestoTipProvider
		{
			get {return MjestoTipProvider as SqlMjestoTipProvider;}
		}
		
		#endregion
		
		
		#region "NAppUpdateProvider"
			
		private SqlNAppUpdateProvider innerSqlNAppUpdateProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NAppUpdate"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NAppUpdateProviderBase NAppUpdateProvider
		{
			get
			{
				if (innerSqlNAppUpdateProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNAppUpdateProvider == null)
						{
							this.innerSqlNAppUpdateProvider = new SqlNAppUpdateProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNAppUpdateProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlNAppUpdateProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNAppUpdateProvider SqlNAppUpdateProvider
		{
			get {return NAppUpdateProvider as SqlNAppUpdateProvider;}
		}
		
		#endregion
		
		
		#region "ObracunProvider"
			
		private SqlObracunProvider innerSqlObracunProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Obracun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunProviderBase ObracunProvider
		{
			get
			{
				if (innerSqlObracunProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunProvider == null)
						{
							this.innerSqlObracunProvider = new SqlObracunProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunProvider SqlObracunProvider
		{
			get {return ObracunProvider as SqlObracunProvider;}
		}
		
		#endregion
		
		
		#region "NacinTransportaProvider"
			
		private SqlNacinTransportaProvider innerSqlNacinTransportaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NacinTransporta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NacinTransportaProviderBase NacinTransportaProvider
		{
			get
			{
				if (innerSqlNacinTransportaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNacinTransportaProvider == null)
						{
							this.innerSqlNacinTransportaProvider = new SqlNacinTransportaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNacinTransportaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlNacinTransportaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNacinTransportaProvider SqlNacinTransportaProvider
		{
			get {return NacinTransportaProvider as SqlNacinTransportaProvider;}
		}
		
		#endregion
		
		
		#region "GrupaDjelatnikParametraProvider"
			
		private SqlGrupaDjelatnikParametraProvider innerSqlGrupaDjelatnikParametraProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GrupaDjelatnikParametra"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GrupaDjelatnikParametraProviderBase GrupaDjelatnikParametraProvider
		{
			get
			{
				if (innerSqlGrupaDjelatnikParametraProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGrupaDjelatnikParametraProvider == null)
						{
							this.innerSqlGrupaDjelatnikParametraProvider = new SqlGrupaDjelatnikParametraProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGrupaDjelatnikParametraProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlGrupaDjelatnikParametraProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGrupaDjelatnikParametraProvider SqlGrupaDjelatnikParametraProvider
		{
			get {return GrupaDjelatnikParametraProvider as SqlGrupaDjelatnikParametraProvider;}
		}
		
		#endregion
		
		
		#region "KontoProvider"
			
		private SqlKontoProvider innerSqlKontoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Konto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KontoProviderBase KontoProvider
		{
			get
			{
				if (innerSqlKontoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKontoProvider == null)
						{
							this.innerSqlKontoProvider = new SqlKontoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKontoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKontoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKontoProvider SqlKontoProvider
		{
			get {return KontoProvider as SqlKontoProvider;}
		}
		
		#endregion
		
		
		#region "ObracunKamataProvider"
			
		private SqlObracunKamataProvider innerSqlObracunKamataProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunKamata"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunKamataProviderBase ObracunKamataProvider
		{
			get
			{
				if (innerSqlObracunKamataProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunKamataProvider == null)
						{
							this.innerSqlObracunKamataProvider = new SqlObracunKamataProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunKamataProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunKamataProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunKamataProvider SqlObracunKamataProvider
		{
			get {return ObracunKamataProvider as SqlObracunKamataProvider;}
		}
		
		#endregion
		
		
		#region "NacinPlacanjaProvider"
			
		private SqlNacinPlacanjaProvider innerSqlNacinPlacanjaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="NacinPlacanja"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override NacinPlacanjaProviderBase NacinPlacanjaProvider
		{
			get
			{
				if (innerSqlNacinPlacanjaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlNacinPlacanjaProvider == null)
						{
							this.innerSqlNacinPlacanjaProvider = new SqlNacinPlacanjaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlNacinPlacanjaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlNacinPlacanjaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlNacinPlacanjaProvider SqlNacinPlacanjaProvider
		{
			get {return NacinPlacanjaProvider as SqlNacinPlacanjaProvider;}
		}
		
		#endregion
		
		
		#region "ObracunOsobaProvider"
			
		private SqlObracunOsobaProvider innerSqlObracunOsobaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunOsobaProviderBase ObracunOsobaProvider
		{
			get
			{
				if (innerSqlObracunOsobaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunOsobaProvider == null)
						{
							this.innerSqlObracunOsobaProvider = new SqlObracunOsobaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunOsobaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunOsobaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunOsobaProvider SqlObracunOsobaProvider
		{
			get {return ObracunOsobaProvider as SqlObracunOsobaProvider;}
		}
		
		#endregion
		
		
		#region "ObracunKamataProknjizenProvider"
			
		private SqlObracunKamataProknjizenProvider innerSqlObracunKamataProknjizenProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunKamataProknjizen"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunKamataProknjizenProviderBase ObracunKamataProknjizenProvider
		{
			get
			{
				if (innerSqlObracunKamataProknjizenProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunKamataProknjizenProvider == null)
						{
							this.innerSqlObracunKamataProknjizenProvider = new SqlObracunKamataProknjizenProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunKamataProknjizenProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunKamataProknjizenProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunKamataProknjizenProvider SqlObracunKamataProknjizenProvider
		{
			get {return ObracunKamataProknjizenProvider as SqlObracunKamataProknjizenProvider;}
		}
		
		#endregion
		
		
		#region "IspisProvider"
			
		private SqlIspisProvider innerSqlIspisProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Ispis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override IspisProviderBase IspisProvider
		{
			get
			{
				if (innerSqlIspisProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlIspisProvider == null)
						{
							this.innerSqlIspisProvider = new SqlIspisProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlIspisProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlIspisProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlIspisProvider SqlIspisProvider
		{
			get {return IspisProvider as SqlIspisProvider;}
		}
		
		#endregion
		
		
		#region "ObracunOsobaObustavaNaknadaProvider"
			
		private SqlObracunOsobaObustavaNaknadaProvider innerSqlObracunOsobaObustavaNaknadaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunOsobaObustavaNaknada"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunOsobaObustavaNaknadaProviderBase ObracunOsobaObustavaNaknadaProvider
		{
			get
			{
				if (innerSqlObracunOsobaObustavaNaknadaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunOsobaObustavaNaknadaProvider == null)
						{
							this.innerSqlObracunOsobaObustavaNaknadaProvider = new SqlObracunOsobaObustavaNaknadaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunOsobaObustavaNaknadaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunOsobaObustavaNaknadaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunOsobaObustavaNaknadaProvider SqlObracunOsobaObustavaNaknadaProvider
		{
			get {return ObracunOsobaObustavaNaknadaProvider as SqlObracunOsobaObustavaNaknadaProvider;}
		}
		
		#endregion
		
		
		#region "ObracunKamataShemaKnjizProvider"
			
		private SqlObracunKamataShemaKnjizProvider innerSqlObracunKamataShemaKnjizProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunKamataShemaKnjiz"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunKamataShemaKnjizProviderBase ObracunKamataShemaKnjizProvider
		{
			get
			{
				if (innerSqlObracunKamataShemaKnjizProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunKamataShemaKnjizProvider == null)
						{
							this.innerSqlObracunKamataShemaKnjizProvider = new SqlObracunKamataShemaKnjizProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunKamataShemaKnjizProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunKamataShemaKnjizProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunKamataShemaKnjizProvider SqlObracunKamataShemaKnjizProvider
		{
			get {return ObracunKamataShemaKnjizProvider as SqlObracunKamataShemaKnjizProvider;}
		}
		
		#endregion
		
		
		#region "IspisKolonaProvider"
			
		private SqlIspisKolonaProvider innerSqlIspisKolonaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="IspisKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override IspisKolonaProviderBase IspisKolonaProvider
		{
			get
			{
				if (innerSqlIspisKolonaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlIspisKolonaProvider == null)
						{
							this.innerSqlIspisKolonaProvider = new SqlIspisKolonaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlIspisKolonaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlIspisKolonaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlIspisKolonaProvider SqlIspisKolonaProvider
		{
			get {return IspisKolonaProvider as SqlIspisKolonaProvider;}
		}
		
		#endregion
		
		
		#region "ObracunOsobaPoreznaOlaksicaProvider"
			
		private SqlObracunOsobaPoreznaOlaksicaProvider innerSqlObracunOsobaPoreznaOlaksicaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunOsobaPoreznaOlaksica"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunOsobaPoreznaOlaksicaProviderBase ObracunOsobaPoreznaOlaksicaProvider
		{
			get
			{
				if (innerSqlObracunOsobaPoreznaOlaksicaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunOsobaPoreznaOlaksicaProvider == null)
						{
							this.innerSqlObracunOsobaPoreznaOlaksicaProvider = new SqlObracunOsobaPoreznaOlaksicaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunOsobaPoreznaOlaksicaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunOsobaPoreznaOlaksicaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunOsobaPoreznaOlaksicaProvider SqlObracunOsobaPoreznaOlaksicaProvider
		{
			get {return ObracunOsobaPoreznaOlaksicaProvider as SqlObracunOsobaPoreznaOlaksicaProvider;}
		}
		
		#endregion
		
		
		#region "ObracunKamataStavkeProvider"
			
		private SqlObracunKamataStavkeProvider innerSqlObracunKamataStavkeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="ObracunKamataStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ObracunKamataStavkeProviderBase ObracunKamataStavkeProvider
		{
			get
			{
				if (innerSqlObracunKamataStavkeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlObracunKamataStavkeProvider == null)
						{
							this.innerSqlObracunKamataStavkeProvider = new SqlObracunKamataStavkeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlObracunKamataStavkeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlObracunKamataStavkeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlObracunKamataStavkeProvider SqlObracunKamataStavkeProvider
		{
			get {return ObracunKamataStavkeProvider as SqlObracunKamataStavkeProvider;}
		}
		
		#endregion
		
		
		#region "GrupaDozvoleProvider"
			
		private SqlGrupaDozvoleProvider innerSqlGrupaDozvoleProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GrupaDozvole"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GrupaDozvoleProviderBase GrupaDozvoleProvider
		{
			get
			{
				if (innerSqlGrupaDozvoleProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGrupaDozvoleProvider == null)
						{
							this.innerSqlGrupaDozvoleProvider = new SqlGrupaDozvoleProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGrupaDozvoleProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlGrupaDozvoleProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGrupaDozvoleProvider SqlGrupaDozvoleProvider
		{
			get {return GrupaDozvoleProvider as SqlGrupaDozvoleProvider;}
		}
		
		#endregion
		
		
		#region "GrupaDjelatnikReportProvider"
			
		private SqlGrupaDjelatnikReportProvider innerSqlGrupaDjelatnikReportProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="GrupaDjelatnikReport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override GrupaDjelatnikReportProviderBase GrupaDjelatnikReportProvider
		{
			get
			{
				if (innerSqlGrupaDjelatnikReportProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlGrupaDjelatnikReportProvider == null)
						{
							this.innerSqlGrupaDjelatnikReportProvider = new SqlGrupaDjelatnikReportProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlGrupaDjelatnikReportProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlGrupaDjelatnikReportProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlGrupaDjelatnikReportProvider SqlGrupaDjelatnikReportProvider
		{
			get {return GrupaDjelatnikReportProvider as SqlGrupaDjelatnikReportProvider;}
		}
		
		#endregion
		
		
		#region "MjestoProvider"
			
		private SqlMjestoProvider innerSqlMjestoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Mjesto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override MjestoProviderBase MjestoProvider
		{
			get
			{
				if (innerSqlMjestoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlMjestoProvider == null)
						{
							this.innerSqlMjestoProvider = new SqlMjestoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlMjestoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlMjestoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlMjestoProvider SqlMjestoProvider
		{
			get {return MjestoProvider as SqlMjestoProvider;}
		}
		
		#endregion
		
		
		#region "InvaliditetProvider"
			
		private SqlInvaliditetProvider innerSqlInvaliditetProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Invaliditet"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override InvaliditetProviderBase InvaliditetProvider
		{
			get
			{
				if (innerSqlInvaliditetProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlInvaliditetProvider == null)
						{
							this.innerSqlInvaliditetProvider = new SqlInvaliditetProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlInvaliditetProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlInvaliditetProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlInvaliditetProvider SqlInvaliditetProvider
		{
			get {return InvaliditetProvider as SqlInvaliditetProvider;}
		}
		
		#endregion
		
		
		#region "KlijentProvider"
			
		private SqlKlijentProvider innerSqlKlijentProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Klijent"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KlijentProviderBase KlijentProvider
		{
			get
			{
				if (innerSqlKlijentProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKlijentProvider == null)
						{
							this.innerSqlKlijentProvider = new SqlKlijentProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKlijentProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKlijentProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKlijentProvider SqlKlijentProvider
		{
			get {return KlijentProvider as SqlKlijentProvider;}
		}
		
		#endregion
		
		
		#region "KlijentTipProvider"
			
		private SqlKlijentTipProvider innerSqlKlijentTipProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KlijentTip"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KlijentTipProviderBase KlijentTipProvider
		{
			get
			{
				if (innerSqlKlijentTipProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKlijentTipProvider == null)
						{
							this.innerSqlKlijentTipProvider = new SqlKlijentTipProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKlijentTipProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKlijentTipProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKlijentTipProvider SqlKlijentTipProvider
		{
			get {return KlijentTipProvider as SqlKlijentTipProvider;}
		}
		
		#endregion
		
		
		#region "KnjizenjeProvider"
			
		private SqlKnjizenjeProvider innerSqlKnjizenjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Knjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KnjizenjeProviderBase KnjizenjeProvider
		{
			get
			{
				if (innerSqlKnjizenjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKnjizenjeProvider == null)
						{
							this.innerSqlKnjizenjeProvider = new SqlKnjizenjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKnjizenjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKnjizenjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKnjizenjeProvider SqlKnjizenjeProvider
		{
			get {return KnjizenjeProvider as SqlKnjizenjeProvider;}
		}
		
		#endregion
		
		
		#region "KnjizenjeStavkaProvider"
			
		private SqlKnjizenjeStavkaProvider innerSqlKnjizenjeStavkaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KnjizenjeStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KnjizenjeStavkaProviderBase KnjizenjeStavkaProvider
		{
			get
			{
				if (innerSqlKnjizenjeStavkaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKnjizenjeStavkaProvider == null)
						{
							this.innerSqlKnjizenjeStavkaProvider = new SqlKnjizenjeStavkaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKnjizenjeStavkaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKnjizenjeStavkaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKnjizenjeStavkaProvider SqlKnjizenjeStavkaProvider
		{
			get {return KnjizenjeStavkaProvider as SqlKnjizenjeStavkaProvider;}
		}
		
		#endregion
		
		
		#region "KlijentNapomenaProvider"
			
		private SqlKlijentNapomenaProvider innerSqlKlijentNapomenaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KlijentNapomena"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KlijentNapomenaProviderBase KlijentNapomenaProvider
		{
			get
			{
				if (innerSqlKlijentNapomenaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKlijentNapomenaProvider == null)
						{
							this.innerSqlKlijentNapomenaProvider = new SqlKlijentNapomenaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKlijentNapomenaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKlijentNapomenaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKlijentNapomenaProvider SqlKlijentNapomenaProvider
		{
			get {return KlijentNapomenaProvider as SqlKlijentNapomenaProvider;}
		}
		
		#endregion
		
		
		#region "IzvadakProvider"
			
		private SqlIzvadakProvider innerSqlIzvadakProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Izvadak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override IzvadakProviderBase IzvadakProvider
		{
			get
			{
				if (innerSqlIzvadakProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlIzvadakProvider == null)
						{
							this.innerSqlIzvadakProvider = new SqlIzvadakProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlIzvadakProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlIzvadakProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlIzvadakProvider SqlIzvadakProvider
		{
			get {return IzvadakProvider as SqlIzvadakProvider;}
		}
		
		#endregion
		
		
		#region "KlijentOsobaProvider"
			
		private SqlKlijentOsobaProvider innerSqlKlijentOsobaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KlijentOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KlijentOsobaProviderBase KlijentOsobaProvider
		{
			get
			{
				if (innerSqlKlijentOsobaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKlijentOsobaProvider == null)
						{
							this.innerSqlKlijentOsobaProvider = new SqlKlijentOsobaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKlijentOsobaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKlijentOsobaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKlijentOsobaProvider SqlKlijentOsobaProvider
		{
			get {return KlijentOsobaProvider as SqlKlijentOsobaProvider;}
		}
		
		#endregion
		
		
		#region "KlijentBankovniRacunProvider"
			
		private SqlKlijentBankovniRacunProvider innerSqlKlijentBankovniRacunProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KlijentBankovniRacun"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KlijentBankovniRacunProviderBase KlijentBankovniRacunProvider
		{
			get
			{
				if (innerSqlKlijentBankovniRacunProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKlijentBankovniRacunProvider == null)
						{
							this.innerSqlKlijentBankovniRacunProvider = new SqlKlijentBankovniRacunProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKlijentBankovniRacunProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKlijentBankovniRacunProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKlijentBankovniRacunProvider SqlKlijentBankovniRacunProvider
		{
			get {return KlijentBankovniRacunProvider as SqlKlijentBankovniRacunProvider;}
		}
		
		#endregion
		
		
		#region "KontoKolonaProvider"
			
		private SqlKontoKolonaProvider innerSqlKontoKolonaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="KontoKolona"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override KontoKolonaProviderBase KontoKolonaProvider
		{
			get
			{
				if (innerSqlKontoKolonaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlKontoKolonaProvider == null)
						{
							this.innerSqlKontoKolonaProvider = new SqlKontoKolonaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlKontoKolonaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlKontoKolonaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlKontoKolonaProvider SqlKontoKolonaProvider
		{
			get {return KontoKolonaProvider as SqlKontoKolonaProvider;}
		}
		
		#endregion
		
		
		#region "ZatvaranjeProvider"
			
		private SqlZatvaranjeProvider innerSqlZatvaranjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="Zatvaranje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override ZatvaranjeProviderBase ZatvaranjeProvider
		{
			get
			{
				if (innerSqlZatvaranjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlZatvaranjeProvider == null)
						{
							this.innerSqlZatvaranjeProvider = new SqlZatvaranjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlZatvaranjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlZatvaranjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlZatvaranjeProvider SqlZatvaranjeProvider
		{
			get {return ZatvaranjeProvider as SqlZatvaranjeProvider;}
		}
		
		#endregion
		
		
		
		#region "VwArtiklKategorijaProvider"
		
		private SqlVwArtiklKategorijaProvider innerSqlVwArtiklKategorijaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwArtiklKategorija"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwArtiklKategorijaProviderBase VwArtiklKategorijaProvider
		{
			get
			{
				if (innerSqlVwArtiklKategorijaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwArtiklKategorijaProvider == null)
						{
							this.innerSqlVwArtiklKategorijaProvider = new SqlVwArtiklKategorijaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwArtiklKategorijaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwArtiklKategorijaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwArtiklKategorijaProvider SqlVwArtiklKategorijaProvider
		{
			get {return VwArtiklKategorijaProvider as SqlVwArtiklKategorijaProvider;}
		}
		
		#endregion
		
		
		#region "VwArtiklStanjeuSkladistuProvider"
		
		private SqlVwArtiklStanjeuSkladistuProvider innerSqlVwArtiklStanjeuSkladistuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwArtiklStanjeuSkladistu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwArtiklStanjeuSkladistuProviderBase VwArtiklStanjeuSkladistuProvider
		{
			get
			{
				if (innerSqlVwArtiklStanjeuSkladistuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwArtiklStanjeuSkladistuProvider == null)
						{
							this.innerSqlVwArtiklStanjeuSkladistuProvider = new SqlVwArtiklStanjeuSkladistuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwArtiklStanjeuSkladistuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwArtiklStanjeuSkladistuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwArtiklStanjeuSkladistuProvider SqlVwArtiklStanjeuSkladistuProvider
		{
			get {return VwArtiklStanjeuSkladistuProvider as SqlVwArtiklStanjeuSkladistuProvider;}
		}
		
		#endregion
		
		
		#region "VwArtiklStanjeVPCProvider"
		
		private SqlVwArtiklStanjeVPCProvider innerSqlVwArtiklStanjeVPCProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwArtiklStanjeVPC"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwArtiklStanjeVPCProviderBase VwArtiklStanjeVPCProvider
		{
			get
			{
				if (innerSqlVwArtiklStanjeVPCProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwArtiklStanjeVPCProvider == null)
						{
							this.innerSqlVwArtiklStanjeVPCProvider = new SqlVwArtiklStanjeVPCProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwArtiklStanjeVPCProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwArtiklStanjeVPCProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwArtiklStanjeVPCProvider SqlVwArtiklStanjeVPCProvider
		{
			get {return VwArtiklStanjeVPCProvider as SqlVwArtiklStanjeVPCProvider;}
		}
		
		#endregion
		
		
		#region "VwArtiklTraziProvider"
		
		private SqlVwArtiklTraziProvider innerSqlVwArtiklTraziProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwArtiklTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwArtiklTraziProviderBase VwArtiklTraziProvider
		{
			get
			{
				if (innerSqlVwArtiklTraziProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwArtiklTraziProvider == null)
						{
							this.innerSqlVwArtiklTraziProvider = new SqlVwArtiklTraziProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwArtiklTraziProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwArtiklTraziProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwArtiklTraziProvider SqlVwArtiklTraziProvider
		{
			get {return VwArtiklTraziProvider as SqlVwArtiklTraziProvider;}
		}
		
		#endregion
		
		
		#region "VwBankaProvider"
		
		private SqlVwBankaProvider innerSqlVwBankaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwBanka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwBankaProviderBase VwBankaProvider
		{
			get
			{
				if (innerSqlVwBankaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwBankaProvider == null)
						{
							this.innerSqlVwBankaProvider = new SqlVwBankaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwBankaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwBankaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwBankaProvider SqlVwBankaProvider
		{
			get {return VwBankaProvider as SqlVwBankaProvider;}
		}
		
		#endregion
		
		
		#region "VwBlagajnaIzvjestajSaldoProvider"
		
		private SqlVwBlagajnaIzvjestajSaldoProvider innerSqlVwBlagajnaIzvjestajSaldoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwBlagajnaIzvjestajSaldo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwBlagajnaIzvjestajSaldoProviderBase VwBlagajnaIzvjestajSaldoProvider
		{
			get
			{
				if (innerSqlVwBlagajnaIzvjestajSaldoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwBlagajnaIzvjestajSaldoProvider == null)
						{
							this.innerSqlVwBlagajnaIzvjestajSaldoProvider = new SqlVwBlagajnaIzvjestajSaldoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwBlagajnaIzvjestajSaldoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwBlagajnaIzvjestajSaldoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwBlagajnaIzvjestajSaldoProvider SqlVwBlagajnaIzvjestajSaldoProvider
		{
			get {return VwBlagajnaIzvjestajSaldoProvider as SqlVwBlagajnaIzvjestajSaldoProvider;}
		}
		
		#endregion
		
		
		#region "VwBlagajnaSaldoProvider"
		
		private SqlVwBlagajnaSaldoProvider innerSqlVwBlagajnaSaldoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwBlagajnaSaldo"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwBlagajnaSaldoProviderBase VwBlagajnaSaldoProvider
		{
			get
			{
				if (innerSqlVwBlagajnaSaldoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwBlagajnaSaldoProvider == null)
						{
							this.innerSqlVwBlagajnaSaldoProvider = new SqlVwBlagajnaSaldoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwBlagajnaSaldoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwBlagajnaSaldoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwBlagajnaSaldoProvider SqlVwBlagajnaSaldoProvider
		{
			get {return VwBlagajnaSaldoProvider as SqlVwBlagajnaSaldoProvider;}
		}
		
		#endregion
		
		
		#region "VwBlagajnaStavkaProvider"
		
		private SqlVwBlagajnaStavkaProvider innerSqlVwBlagajnaStavkaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwBlagajnaStavka"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwBlagajnaStavkaProviderBase VwBlagajnaStavkaProvider
		{
			get
			{
				if (innerSqlVwBlagajnaStavkaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwBlagajnaStavkaProvider == null)
						{
							this.innerSqlVwBlagajnaStavkaProvider = new SqlVwBlagajnaStavkaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwBlagajnaStavkaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwBlagajnaStavkaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwBlagajnaStavkaProvider SqlVwBlagajnaStavkaProvider
		{
			get {return VwBlagajnaStavkaProvider as SqlVwBlagajnaStavkaProvider;}
		}
		
		#endregion
		
		
		#region "VwDefParametriDjelatnikaProvider"
		
		private SqlVwDefParametriDjelatnikaProvider innerSqlVwDefParametriDjelatnikaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwDefParametriDjelatnika"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwDefParametriDjelatnikaProviderBase VwDefParametriDjelatnikaProvider
		{
			get
			{
				if (innerSqlVwDefParametriDjelatnikaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwDefParametriDjelatnikaProvider == null)
						{
							this.innerSqlVwDefParametriDjelatnikaProvider = new SqlVwDefParametriDjelatnikaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwDefParametriDjelatnikaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwDefParametriDjelatnikaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwDefParametriDjelatnikaProvider SqlVwDefParametriDjelatnikaProvider
		{
			get {return VwDefParametriDjelatnikaProvider as SqlVwDefParametriDjelatnikaProvider;}
		}
		
		#endregion
		
		
		#region "VwDokumentProvider"
		
		private SqlVwDokumentProvider innerSqlVwDokumentProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwDokument"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwDokumentProviderBase VwDokumentProvider
		{
			get
			{
				if (innerSqlVwDokumentProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwDokumentProvider == null)
						{
							this.innerSqlVwDokumentProvider = new SqlVwDokumentProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwDokumentProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwDokumentProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwDokumentProvider SqlVwDokumentProvider
		{
			get {return VwDokumentProvider as SqlVwDokumentProvider;}
		}
		
		#endregion
		
		
		#region "VwDozvoleGrupeProvider"
		
		private SqlVwDozvoleGrupeProvider innerSqlVwDozvoleGrupeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwDozvoleGrupe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwDozvoleGrupeProviderBase VwDozvoleGrupeProvider
		{
			get
			{
				if (innerSqlVwDozvoleGrupeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwDozvoleGrupeProvider == null)
						{
							this.innerSqlVwDozvoleGrupeProvider = new SqlVwDozvoleGrupeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwDozvoleGrupeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwDozvoleGrupeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwDozvoleGrupeProvider SqlVwDozvoleGrupeProvider
		{
			get {return VwDozvoleGrupeProvider as SqlVwDozvoleGrupeProvider;}
		}
		
		#endregion
		
		
		#region "VwDozvoleOrganizacijeProvider"
		
		private SqlVwDozvoleOrganizacijeProvider innerSqlVwDozvoleOrganizacijeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwDozvoleOrganizacije"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwDozvoleOrganizacijeProviderBase VwDozvoleOrganizacijeProvider
		{
			get
			{
				if (innerSqlVwDozvoleOrganizacijeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwDozvoleOrganizacijeProvider == null)
						{
							this.innerSqlVwDozvoleOrganizacijeProvider = new SqlVwDozvoleOrganizacijeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwDozvoleOrganizacijeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwDozvoleOrganizacijeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwDozvoleOrganizacijeProvider SqlVwDozvoleOrganizacijeProvider
		{
			get {return VwDozvoleOrganizacijeProvider as SqlVwDozvoleOrganizacijeProvider;}
		}
		
		#endregion
		
		
		#region "VwIspisProvider"
		
		private SqlVwIspisProvider innerSqlVwIspisProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwIspis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwIspisProviderBase VwIspisProvider
		{
			get
			{
				if (innerSqlVwIspisProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwIspisProvider == null)
						{
							this.innerSqlVwIspisProvider = new SqlVwIspisProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwIspisProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwIspisProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwIspisProvider SqlVwIspisProvider
		{
			get {return VwIspisProvider as SqlVwIspisProvider;}
		}
		
		#endregion
		
		
		#region "VwIzvadakProvider"
		
		private SqlVwIzvadakProvider innerSqlVwIzvadakProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwIzvadak"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwIzvadakProviderBase VwIzvadakProvider
		{
			get
			{
				if (innerSqlVwIzvadakProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwIzvadakProvider == null)
						{
							this.innerSqlVwIzvadakProvider = new SqlVwIzvadakProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwIzvadakProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwIzvadakProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwIzvadakProvider SqlVwIzvadakProvider
		{
			get {return VwIzvadakProvider as SqlVwIzvadakProvider;}
		}
		
		#endregion
		
		
		#region "VwKlijentProvider"
		
		private SqlVwKlijentProvider innerSqlVwKlijentProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwKlijent"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwKlijentProviderBase VwKlijentProvider
		{
			get
			{
				if (innerSqlVwKlijentProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwKlijentProvider == null)
						{
							this.innerSqlVwKlijentProvider = new SqlVwKlijentProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwKlijentProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwKlijentProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwKlijentProvider SqlVwKlijentProvider
		{
			get {return VwKlijentProvider as SqlVwKlijentProvider;}
		}
		
		#endregion
		
		
		#region "VwKnjizenjeProvider"
		
		private SqlVwKnjizenjeProvider innerSqlVwKnjizenjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwKnjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwKnjizenjeProviderBase VwKnjizenjeProvider
		{
			get
			{
				if (innerSqlVwKnjizenjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwKnjizenjeProvider == null)
						{
							this.innerSqlVwKnjizenjeProvider = new SqlVwKnjizenjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwKnjizenjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwKnjizenjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwKnjizenjeProvider SqlVwKnjizenjeProvider
		{
			get {return VwKnjizenjeProvider as SqlVwKnjizenjeProvider;}
		}
		
		#endregion
		
		
		#region "VwKnjizenjeIspisProvider"
		
		private SqlVwKnjizenjeIspisProvider innerSqlVwKnjizenjeIspisProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwKnjizenjeIspis"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwKnjizenjeIspisProviderBase VwKnjizenjeIspisProvider
		{
			get
			{
				if (innerSqlVwKnjizenjeIspisProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwKnjizenjeIspisProvider == null)
						{
							this.innerSqlVwKnjizenjeIspisProvider = new SqlVwKnjizenjeIspisProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwKnjizenjeIspisProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwKnjizenjeIspisProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwKnjizenjeIspisProvider SqlVwKnjizenjeIspisProvider
		{
			get {return VwKnjizenjeIspisProvider as SqlVwKnjizenjeIspisProvider;}
		}
		
		#endregion
		
		
		#region "VwKontoProvider"
		
		private SqlVwKontoProvider innerSqlVwKontoProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwKonto"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwKontoProviderBase VwKontoProvider
		{
			get
			{
				if (innerSqlVwKontoProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwKontoProvider == null)
						{
							this.innerSqlVwKontoProvider = new SqlVwKontoProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwKontoProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwKontoProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwKontoProvider SqlVwKontoProvider
		{
			get {return VwKontoProvider as SqlVwKontoProvider;}
		}
		
		#endregion
		
		
		#region "VwKopiranjeDokumentaProvider"
		
		private SqlVwKopiranjeDokumentaProvider innerSqlVwKopiranjeDokumentaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwKopiranjeDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwKopiranjeDokumentaProviderBase VwKopiranjeDokumentaProvider
		{
			get
			{
				if (innerSqlVwKopiranjeDokumentaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwKopiranjeDokumentaProvider == null)
						{
							this.innerSqlVwKopiranjeDokumentaProvider = new SqlVwKopiranjeDokumentaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwKopiranjeDokumentaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwKopiranjeDokumentaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwKopiranjeDokumentaProvider SqlVwKopiranjeDokumentaProvider
		{
			get {return VwKopiranjeDokumentaProvider as SqlVwKopiranjeDokumentaProvider;}
		}
		
		#endregion
		
		
		#region "VwNc_Po_DobavljacuProvider"
		
		private SqlVwNc_Po_DobavljacuProvider innerSqlVwNc_Po_DobavljacuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwNc_Po_Dobavljacu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwNc_Po_DobavljacuProviderBase VwNc_Po_DobavljacuProvider
		{
			get
			{
				if (innerSqlVwNc_Po_DobavljacuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwNc_Po_DobavljacuProvider == null)
						{
							this.innerSqlVwNc_Po_DobavljacuProvider = new SqlVwNc_Po_DobavljacuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwNc_Po_DobavljacuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwNc_Po_DobavljacuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwNc_Po_DobavljacuProvider SqlVwNc_Po_DobavljacuProvider
		{
			get {return VwNc_Po_DobavljacuProvider as SqlVwNc_Po_DobavljacuProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunDefaultVrijednostiProvider"
		
		private SqlVwObracunDefaultVrijednostiProvider innerSqlVwObracunDefaultVrijednostiProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunDefaultVrijednosti"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunDefaultVrijednostiProviderBase VwObracunDefaultVrijednostiProvider
		{
			get
			{
				if (innerSqlVwObracunDefaultVrijednostiProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunDefaultVrijednostiProvider == null)
						{
							this.innerSqlVwObracunDefaultVrijednostiProvider = new SqlVwObracunDefaultVrijednostiProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunDefaultVrijednostiProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunDefaultVrijednostiProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunDefaultVrijednostiProvider SqlVwObracunDefaultVrijednostiProvider
		{
			get {return VwObracunDefaultVrijednostiProvider as SqlVwObracunDefaultVrijednostiProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunKamataProvider"
		
		private SqlVwObracunKamataProvider innerSqlVwObracunKamataProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunKamata"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunKamataProviderBase VwObracunKamataProvider
		{
			get
			{
				if (innerSqlVwObracunKamataProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunKamataProvider == null)
						{
							this.innerSqlVwObracunKamataProvider = new SqlVwObracunKamataProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunKamataProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunKamataProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunKamataProvider SqlVwObracunKamataProvider
		{
			get {return VwObracunKamataProvider as SqlVwObracunKamataProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunKamataTraziProvider"
		
		private SqlVwObracunKamataTraziProvider innerSqlVwObracunKamataTraziProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunKamataTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunKamataTraziProviderBase VwObracunKamataTraziProvider
		{
			get
			{
				if (innerSqlVwObracunKamataTraziProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunKamataTraziProvider == null)
						{
							this.innerSqlVwObracunKamataTraziProvider = new SqlVwObracunKamataTraziProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunKamataTraziProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunKamataTraziProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunKamataTraziProvider SqlVwObracunKamataTraziProvider
		{
			get {return VwObracunKamataTraziProvider as SqlVwObracunKamataTraziProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunSpecifikacijaPoBankamaProvider"
		
		private SqlVwObracunSpecifikacijaPoBankamaProvider innerSqlVwObracunSpecifikacijaPoBankamaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunSpecifikacijaPoBankama"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunSpecifikacijaPoBankamaProviderBase VwObracunSpecifikacijaPoBankamaProvider
		{
			get
			{
				if (innerSqlVwObracunSpecifikacijaPoBankamaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunSpecifikacijaPoBankamaProvider == null)
						{
							this.innerSqlVwObracunSpecifikacijaPoBankamaProvider = new SqlVwObracunSpecifikacijaPoBankamaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunSpecifikacijaPoBankamaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunSpecifikacijaPoBankamaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunSpecifikacijaPoBankamaProvider SqlVwObracunSpecifikacijaPoBankamaProvider
		{
			get {return VwObracunSpecifikacijaPoBankamaProvider as SqlVwObracunSpecifikacijaPoBankamaProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunTemeljnicaZaKnjizenjeProvider"
		
		private SqlVwObracunTemeljnicaZaKnjizenjeProvider innerSqlVwObracunTemeljnicaZaKnjizenjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunTemeljnicaZaKnjizenje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunTemeljnicaZaKnjizenjeProviderBase VwObracunTemeljnicaZaKnjizenjeProvider
		{
			get
			{
				if (innerSqlVwObracunTemeljnicaZaKnjizenjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunTemeljnicaZaKnjizenjeProvider == null)
						{
							this.innerSqlVwObracunTemeljnicaZaKnjizenjeProvider = new SqlVwObracunTemeljnicaZaKnjizenjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunTemeljnicaZaKnjizenjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunTemeljnicaZaKnjizenjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunTemeljnicaZaKnjizenjeProvider SqlVwObracunTemeljnicaZaKnjizenjeProvider
		{
			get {return VwObracunTemeljnicaZaKnjizenjeProvider as SqlVwObracunTemeljnicaZaKnjizenjeProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunTraziProvider"
		
		private SqlVwObracunTraziProvider innerSqlVwObracunTraziProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunTrazi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunTraziProviderBase VwObracunTraziProvider
		{
			get
			{
				if (innerSqlVwObracunTraziProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunTraziProvider == null)
						{
							this.innerSqlVwObracunTraziProvider = new SqlVwObracunTraziProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunTraziProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunTraziProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunTraziProvider SqlVwObracunTraziProvider
		{
			get {return VwObracunTraziProvider as SqlVwObracunTraziProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunVirmaniProvider"
		
		private SqlVwObracunVirmaniProvider innerSqlVwObracunVirmaniProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunVirmani"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunVirmaniProviderBase VwObracunVirmaniProvider
		{
			get
			{
				if (innerSqlVwObracunVirmaniProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunVirmaniProvider == null)
						{
							this.innerSqlVwObracunVirmaniProvider = new SqlVwObracunVirmaniProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunVirmaniProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunVirmaniProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunVirmaniProvider SqlVwObracunVirmaniProvider
		{
			get {return VwObracunVirmaniProvider as SqlVwObracunVirmaniProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunZaIDProvider"
		
		private SqlVwObracunZaIDProvider innerSqlVwObracunZaIDProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunZaID"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunZaIDProviderBase VwObracunZaIDProvider
		{
			get
			{
				if (innerSqlVwObracunZaIDProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunZaIDProvider == null)
						{
							this.innerSqlVwObracunZaIDProvider = new SqlVwObracunZaIDProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunZaIDProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunZaIDProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunZaIDProvider SqlVwObracunZaIDProvider
		{
			get {return VwObracunZaIDProvider as SqlVwObracunZaIDProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunZaIDPoObrascuProvider"
		
		private SqlVwObracunZaIDPoObrascuProvider innerSqlVwObracunZaIDPoObrascuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunZaIDPoObrascu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunZaIDPoObrascuProviderBase VwObracunZaIDPoObrascuProvider
		{
			get
			{
				if (innerSqlVwObracunZaIDPoObrascuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunZaIDPoObrascuProvider == null)
						{
							this.innerSqlVwObracunZaIDPoObrascuProvider = new SqlVwObracunZaIDPoObrascuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunZaIDPoObrascuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunZaIDPoObrascuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunZaIDPoObrascuProvider SqlVwObracunZaIDPoObrascuProvider
		{
			get {return VwObracunZaIDPoObrascuProvider as SqlVwObracunZaIDPoObrascuProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunZaIDPorezPrirezProvider"
		
		private SqlVwObracunZaIDPorezPrirezProvider innerSqlVwObracunZaIDPorezPrirezProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunZaIDPorezPrirez"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunZaIDPorezPrirezProviderBase VwObracunZaIDPorezPrirezProvider
		{
			get
			{
				if (innerSqlVwObracunZaIDPorezPrirezProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunZaIDPorezPrirezProvider == null)
						{
							this.innerSqlVwObracunZaIDPorezPrirezProvider = new SqlVwObracunZaIDPorezPrirezProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunZaIDPorezPrirezProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunZaIDPorezPrirezProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunZaIDPorezPrirezProvider SqlVwObracunZaIDPorezPrirezProvider
		{
			get {return VwObracunZaIDPorezPrirezProvider as SqlVwObracunZaIDPorezPrirezProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunZaIDPorezPrirezPoObrascuProvider"
		
		private SqlVwObracunZaIDPorezPrirezPoObrascuProvider innerSqlVwObracunZaIDPorezPrirezPoObrascuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunZaIDPorezPrirezPoObrascu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunZaIDPorezPrirezPoObrascuProviderBase VwObracunZaIDPorezPrirezPoObrascuProvider
		{
			get
			{
				if (innerSqlVwObracunZaIDPorezPrirezPoObrascuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunZaIDPorezPrirezPoObrascuProvider == null)
						{
							this.innerSqlVwObracunZaIDPorezPrirezPoObrascuProvider = new SqlVwObracunZaIDPorezPrirezPoObrascuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunZaIDPorezPrirezPoObrascuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunZaIDPorezPrirezPoObrascuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunZaIDPorezPrirezPoObrascuProvider SqlVwObracunZaIDPorezPrirezPoObrascuProvider
		{
			get {return VwObracunZaIDPorezPrirezPoObrascuProvider as SqlVwObracunZaIDPorezPrirezPoObrascuProvider;}
		}
		
		#endregion
		
		
		#region "VwObracunZaRegosStavkeProvider"
		
		private SqlVwObracunZaRegosStavkeProvider innerSqlVwObracunZaRegosStavkeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwObracunZaRegosStavke"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwObracunZaRegosStavkeProviderBase VwObracunZaRegosStavkeProvider
		{
			get
			{
				if (innerSqlVwObracunZaRegosStavkeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwObracunZaRegosStavkeProvider == null)
						{
							this.innerSqlVwObracunZaRegosStavkeProvider = new SqlVwObracunZaRegosStavkeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwObracunZaRegosStavkeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwObracunZaRegosStavkeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwObracunZaRegosStavkeProvider SqlVwObracunZaRegosStavkeProvider
		{
			get {return VwObracunZaRegosStavkeProvider as SqlVwObracunZaRegosStavkeProvider;}
		}
		
		#endregion
		
		
		#region "VwOrganizacijaTVProvider"
		
		private SqlVwOrganizacijaTVProvider innerSqlVwOrganizacijaTVProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwOrganizacijaTV"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwOrganizacijaTVProviderBase VwOrganizacijaTVProvider
		{
			get
			{
				if (innerSqlVwOrganizacijaTVProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwOrganizacijaTVProvider == null)
						{
							this.innerSqlVwOrganizacijaTVProvider = new SqlVwOrganizacijaTVProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwOrganizacijaTVProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwOrganizacijaTVProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwOrganizacijaTVProvider SqlVwOrganizacijaTVProvider
		{
			get {return VwOrganizacijaTVProvider as SqlVwOrganizacijaTVProvider;}
		}
		
		#endregion
		
		
		#region "VwOsnovnaSredstvaProvider"
		
		private SqlVwOsnovnaSredstvaProvider innerSqlVwOsnovnaSredstvaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwOsnovnaSredstva"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwOsnovnaSredstvaProviderBase VwOsnovnaSredstvaProvider
		{
			get
			{
				if (innerSqlVwOsnovnaSredstvaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwOsnovnaSredstvaProvider == null)
						{
							this.innerSqlVwOsnovnaSredstvaProvider = new SqlVwOsnovnaSredstvaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwOsnovnaSredstvaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwOsnovnaSredstvaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwOsnovnaSredstvaProvider SqlVwOsnovnaSredstvaProvider
		{
			get {return VwOsnovnaSredstvaProvider as SqlVwOsnovnaSredstvaProvider;}
		}
		
		#endregion
		
		
		#region "VwOsobaProvider"
		
		private SqlVwOsobaProvider innerSqlVwOsobaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwOsoba"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwOsobaProviderBase VwOsobaProvider
		{
			get
			{
				if (innerSqlVwOsobaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwOsobaProvider == null)
						{
							this.innerSqlVwOsobaProvider = new SqlVwOsobaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwOsobaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwOsobaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwOsobaProvider SqlVwOsobaProvider
		{
			get {return VwOsobaProvider as SqlVwOsobaProvider;}
		}
		
		#endregion
		
		
		#region "VwParametriKorisnikaProvider"
		
		private SqlVwParametriKorisnikaProvider innerSqlVwParametriKorisnikaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwParametriKorisnika"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwParametriKorisnikaProviderBase VwParametriKorisnikaProvider
		{
			get
			{
				if (innerSqlVwParametriKorisnikaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwParametriKorisnikaProvider == null)
						{
							this.innerSqlVwParametriKorisnikaProvider = new SqlVwParametriKorisnikaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwParametriKorisnikaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwParametriKorisnikaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwParametriKorisnikaProvider SqlVwParametriKorisnikaProvider
		{
			get {return VwParametriKorisnikaProvider as SqlVwParametriKorisnikaProvider;}
		}
		
		#endregion
		
		
		#region "VwPopisPutnihNalogaProvider"
		
		private SqlVwPopisPutnihNalogaProvider innerSqlVwPopisPutnihNalogaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwPopisPutnihNaloga"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwPopisPutnihNalogaProviderBase VwPopisPutnihNalogaProvider
		{
			get
			{
				if (innerSqlVwPopisPutnihNalogaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwPopisPutnihNalogaProvider == null)
						{
							this.innerSqlVwPopisPutnihNalogaProvider = new SqlVwPopisPutnihNalogaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwPopisPutnihNalogaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwPopisPutnihNalogaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwPopisPutnihNalogaProvider SqlVwPopisPutnihNalogaProvider
		{
			get {return VwPopisPutnihNalogaProvider as SqlVwPopisPutnihNalogaProvider;}
		}
		
		#endregion
		
		
		#region "VwPreostaloZaZatvaranjeProvider"
		
		private SqlVwPreostaloZaZatvaranjeProvider innerSqlVwPreostaloZaZatvaranjeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranje"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwPreostaloZaZatvaranjeProviderBase VwPreostaloZaZatvaranjeProvider
		{
			get
			{
				if (innerSqlVwPreostaloZaZatvaranjeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwPreostaloZaZatvaranjeProvider == null)
						{
							this.innerSqlVwPreostaloZaZatvaranjeProvider = new SqlVwPreostaloZaZatvaranjeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwPreostaloZaZatvaranjeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwPreostaloZaZatvaranjeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwPreostaloZaZatvaranjeProvider SqlVwPreostaloZaZatvaranjeProvider
		{
			get {return VwPreostaloZaZatvaranjeProvider as SqlVwPreostaloZaZatvaranjeProvider;}
		}
		
		#endregion
		
		
		#region "VwPreostaloZaZatvaranjeZapisanoSimpleProvider"
		
		private SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranjeZapisanoSimple"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwPreostaloZaZatvaranjeZapisanoSimpleProviderBase VwPreostaloZaZatvaranjeZapisanoSimpleProvider
		{
			get
			{
				if (innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider == null)
						{
							this.innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider = new SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider
		{
			get {return VwPreostaloZaZatvaranjeZapisanoSimpleProvider as SqlVwPreostaloZaZatvaranjeZapisanoSimpleProvider;}
		}
		
		#endregion
		
		
		#region "VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider"
		
		private SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwPreostaloZaZatvaranjeZapisanoSimpleSvi"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwPreostaloZaZatvaranjeZapisanoSimpleSviProviderBase VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider
		{
			get
			{
				if (innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider == null)
						{
							this.innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider = new SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider
		{
			get {return VwPreostaloZaZatvaranjeZapisanoSimpleSviProvider as SqlVwPreostaloZaZatvaranjeZapisanoSimpleSviProvider;}
		}
		
		#endregion
		
		
		#region "VwPrijenosRadnogNalogaProvider"
		
		private SqlVwPrijenosRadnogNalogaProvider innerSqlVwPrijenosRadnogNalogaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwPrijenosRadnogNaloga"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwPrijenosRadnogNalogaProviderBase VwPrijenosRadnogNalogaProvider
		{
			get
			{
				if (innerSqlVwPrijenosRadnogNalogaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwPrijenosRadnogNalogaProvider == null)
						{
							this.innerSqlVwPrijenosRadnogNalogaProvider = new SqlVwPrijenosRadnogNalogaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwPrijenosRadnogNalogaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwPrijenosRadnogNalogaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwPrijenosRadnogNalogaProvider SqlVwPrijenosRadnogNalogaProvider
		{
			get {return VwPrijenosRadnogNalogaProvider as SqlVwPrijenosRadnogNalogaProvider;}
		}
		
		#endregion
		
		
		#region "VwRabatProvider"
		
		private SqlVwRabatProvider innerSqlVwRabatProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwRabat"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwRabatProviderBase VwRabatProvider
		{
			get
			{
				if (innerSqlVwRabatProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwRabatProvider == null)
						{
							this.innerSqlVwRabatProvider = new SqlVwRabatProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwRabatProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwRabatProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwRabatProvider SqlVwRabatProvider
		{
			get {return VwRabatProvider as SqlVwRabatProvider;}
		}
		
		#endregion
		
		
		#region "VwRadniNalogVezeProvider"
		
		private SqlVwRadniNalogVezeProvider innerSqlVwRadniNalogVezeProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwRadniNalogVeze"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwRadniNalogVezeProviderBase VwRadniNalogVezeProvider
		{
			get
			{
				if (innerSqlVwRadniNalogVezeProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwRadniNalogVezeProvider == null)
						{
							this.innerSqlVwRadniNalogVezeProvider = new SqlVwRadniNalogVezeProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwRadniNalogVezeProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwRadniNalogVezeProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwRadniNalogVezeProvider SqlVwRadniNalogVezeProvider
		{
			get {return VwRadniNalogVezeProvider as SqlVwRadniNalogVezeProvider;}
		}
		
		#endregion
		
		
		#region "VwReportProvider"
		
		private SqlVwReportProvider innerSqlVwReportProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwReport"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwReportProviderBase VwReportProvider
		{
			get
			{
				if (innerSqlVwReportProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwReportProvider == null)
						{
							this.innerSqlVwReportProvider = new SqlVwReportProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwReportProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwReportProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwReportProvider SqlVwReportProvider
		{
			get {return VwReportProvider as SqlVwReportProvider;}
		}
		
		#endregion
		
		
		#region "VwSKPoDokumentimaPoTipuProvider"
		
		private SqlVwSKPoDokumentimaPoTipuProvider innerSqlVwSKPoDokumentimaPoTipuProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwSKPoDokumentimaPoTipu"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwSKPoDokumentimaPoTipuProviderBase VwSKPoDokumentimaPoTipuProvider
		{
			get
			{
				if (innerSqlVwSKPoDokumentimaPoTipuProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwSKPoDokumentimaPoTipuProvider == null)
						{
							this.innerSqlVwSKPoDokumentimaPoTipuProvider = new SqlVwSKPoDokumentimaPoTipuProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwSKPoDokumentimaPoTipuProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwSKPoDokumentimaPoTipuProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwSKPoDokumentimaPoTipuProvider SqlVwSKPoDokumentimaPoTipuProvider
		{
			get {return VwSKPoDokumentimaPoTipuProvider as SqlVwSKPoDokumentimaPoTipuProvider;}
		}
		
		#endregion
		
		
		#region "VwTmpSaldoKlijentaProvider"
		
		private SqlVwTmpSaldoKlijentaProvider innerSqlVwTmpSaldoKlijentaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwTmpSaldoKlijenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwTmpSaldoKlijentaProviderBase VwTmpSaldoKlijentaProvider
		{
			get
			{
				if (innerSqlVwTmpSaldoKlijentaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwTmpSaldoKlijentaProvider == null)
						{
							this.innerSqlVwTmpSaldoKlijentaProvider = new SqlVwTmpSaldoKlijentaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwTmpSaldoKlijentaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwTmpSaldoKlijentaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwTmpSaldoKlijentaProvider SqlVwTmpSaldoKlijentaProvider
		{
			get {return VwTmpSaldoKlijentaProvider as SqlVwTmpSaldoKlijentaProvider;}
		}
		
		#endregion
		
		
		#region "VwVezeDokumentaProvider"
		
		private SqlVwVezeDokumentaProvider innerSqlVwVezeDokumentaProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwVezeDokumenta"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwVezeDokumentaProviderBase VwVezeDokumentaProvider
		{
			get
			{
				if (innerSqlVwVezeDokumentaProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwVezeDokumentaProvider == null)
						{
							this.innerSqlVwVezeDokumentaProvider = new SqlVwVezeDokumentaProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwVezeDokumentaProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwVezeDokumentaProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwVezeDokumentaProvider SqlVwVezeDokumentaProvider
		{
			get {return VwVezeDokumentaProvider as SqlVwVezeDokumentaProvider;}
		}
		
		#endregion
		
		
		#region "VwVirmanOdabirProvider"
		
		private SqlVwVirmanOdabirProvider innerSqlVwVirmanOdabirProvider;

		///<summary>
		/// This class is the Data Access Logic Component for the <see cref="VwVirmanOdabir"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		/// <value></value>
		public override VwVirmanOdabirProviderBase VwVirmanOdabirProvider
		{
			get
			{
				if (innerSqlVwVirmanOdabirProvider == null) 
				{
					lock (syncRoot) 
					{
						if (innerSqlVwVirmanOdabirProvider == null)
						{
							this.innerSqlVwVirmanOdabirProvider = new SqlVwVirmanOdabirProvider(_connectionString, _useStoredProcedure, _providerInvariantName);
						}
					}
				}
				return innerSqlVwVirmanOdabirProvider;
			}
		}
		
		/// <summary>
		/// Gets the current <c cref="SqlVwVirmanOdabirProvider"/>.
		/// </summary>
		/// <value></value>
		public SqlVwVirmanOdabirProvider SqlVwVirmanOdabirProvider
		{
			get {return VwVirmanOdabirProvider as SqlVwVirmanOdabirProvider;}
		}
		
		#endregion
		
		
		#region "General data access methods"

		#region "ExecuteNonQuery"
		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		public override void ExecuteNonQuery(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			database.ExecuteNonQuery(commandWrapper);	
			
		}

		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		public override void ExecuteNonQuery(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			database.ExecuteNonQuery(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteNonQuery(commandType, commandText);	
		}
		/// <summary>
		/// Executes the non query.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override int ExecuteNonQuery(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteNonQuery(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteDataReader"
		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteReader(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteReader(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteReader(commandWrapper);	
		}

		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteReader(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteReader(commandType, commandText);	
		}
		/// <summary>
		/// Executes the reader.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override IDataReader ExecuteReader(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteReader(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteDataSet"
		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteDataSet(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteDataSet(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteDataSet(commandWrapper);	
		}

		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteDataSet(commandWrapper, transactionManager.TransactionObject);	
		}


		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteDataSet(commandType, commandText);	
		}
		/// <summary>
		/// Executes the data set.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override DataSet ExecuteDataSet(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteDataSet(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#region "ExecuteScalar"
		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override object ExecuteScalar(string storedProcedureName, params object[] parameterValues)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteScalar(storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="storedProcedureName">Name of the stored procedure.</param>
		/// <param name="parameterValues">The parameter values.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, string storedProcedureName, params object[] parameterValues)
		{
			Database database = transactionManager.Database;
			return database.ExecuteScalar(transactionManager.TransactionObject, storedProcedureName, parameterValues);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override object ExecuteScalar(DbCommand commandWrapper)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);			
			return database.ExecuteScalar(commandWrapper);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandWrapper">The command wrapper.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, DbCommand commandWrapper)
		{
			Database database = transactionManager.Database;
			return database.ExecuteScalar(commandWrapper, transactionManager.TransactionObject);	
		}

		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override object ExecuteScalar(CommandType commandType, string commandText)
		{
			SqlDatabase database = new SqlDatabase(this._connectionString);
			return database.ExecuteScalar(commandType, commandText);	
		}
		/// <summary>
		/// Executes the scalar.
		/// </summary>
		/// <param name="transactionManager">The transaction manager.</param>
		/// <param name="commandType">Type of the command.</param>
		/// <param name="commandText">The command text.</param>
		/// <returns></returns>
		public override object ExecuteScalar(TransactionManager transactionManager, CommandType commandType, string commandText)
		{
			Database database = transactionManager.Database;			
			return database.ExecuteScalar(transactionManager.TransactionObject , commandType, commandText);				
		}
		#endregion

		#endregion


	}
}
